# Romania Supplier Litigation Monitor (portal.just.ro) (`nocturntools/ro-supplier-litigation`) Actor

Court cases of Romanian companies by CUI from portal.just.ro: case counts, the company's role, matter, stage and factual flags (insolvency as debtor, active defendant, tax and labor disputes). Monitor mode reports only new or changed cases.

- **URL**: https://apify.com/nocturntools/ro-supplier-litigation.md
- **Developed by:** [Nocturn Tools](https://apify.com/nocturntools) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 Supplier Litigation Monitor (portal.just.ro)

Find the court cases of Romanian companies by CUI (fiscal code). For each company the actor searches the public case database of Romanian courts (portal.just.ro) and returns how many cases it has, in what role (claimant, defendant, debtor, creditor), which matters and stages, and a few factual flags: insolvency as debtor, active cases as defendant, criminal cases as defendant, tax disputes, labor disputes, new cases.

Built for **supplier due diligence**: accountants, procurement and finance teams with a list of supplier CUIs who want to know which suppliers are in court, and to be told when something new happens.

**Unofficial tool. Source: portal.just.ro public web service (Romanian Ministry of Justice). Not affiliated with or endorsed by the Ministry of Justice or the courts. Not legal advice. Name-based matching may miss or misattribute cases (renamed/deregistered companies, common names).**

### What you get

- **One row per company**, in your input order: name and ANAF status, number of cases, cases by role and by matter, active cases, **flags**, and (optionally) the list of cases with number, court, matter, stage, the company's role and dates.
- **Only the company's side.** Other parties, the case subject and the court's solutions are never output (they often name private persons).
- **Monitor mode.** Schedule a run (for example weekly) and get only the companies where something changed: a new case, a case updated on the portal (new hearing, new stage, decision…), a flag that appeared or disappeared. Later runs first ask only for cases modified since the last check, so unchanged companies cost one quick request.

### Quick start

1. Paste your suppliers' CUIs into **Company fiscal codes** (with or without `RO`).
2. Click **Start**. By default the actor looks at cases registered in the last 5 years.
3. Open the **Overview** view of the dataset: one row per CUI, flags in the **Flags** column.

#### Input example

```json
{
  "cuis": ["RO18189442", "1475261", "49999996"],
  "sinceYear": 2021,
  "matters": [],
  "includeCaseList": true,
  "monitorMode": false
}
```

#### Output example (shortened; real figures from 2026-11-10, timestamps illustrative)

```json
{
  "cui": "18189442",
  "status": "OK",
  "name": "BITDEFENDER SRL",
  "searchedName": "BITDEFENDER",
  "searchedSince": "2021-01-01",
  "caseCount": 16,
  "caseCountIsLowerBound": false,
  "byRole": { "claimant": 2, "defendant": 8, "debtor": 0, "creditor": 0, "other": 6 },
  "byMatter": { "Litigii de muncă": 10, "Civil": 3, "Contencios administrativ şi fiscal": 2, "Litigii cu profesioniştii": 1 },
  "activeCaseCount": 7,
  "flags": ["ACTIVE_AS_DEFENDANT", "LABOR_DISPUTES", "NEW_CASE_LAST_90D"],
  "cases": [
    {
      "number": "16581/3/2025",
      "court": "Curtea de Apel BUCURESTI",
      "department": "Secţia a VIII-a contencios administrativ şi fiscal",
      "matter": "Contencios administrativ şi fiscal",
      "stage": "Apel",
      "roleOfCompany": "Recurent Reclamant",
      "registeredAt": "2026-10-22",
      "lastModifiedAt": "2026-10-26T11:00:38.997",
      "lastHearingDate": null,
      "nextHearingDate": null,
      "lastHearingDocument": null,
      "active": true
    }
  ],
  "casesTotal": 16,
  "casesTruncatedToLimit": false,
  "truncated": false,
  "notes": ["nearMatchesIgnored: 1 case found by the search only name companies with a similar, longer name; not counted."],
  "sources": [
    { "name": "ANAF registry (VAT v9)", "url": "https://webservicesp.anaf.ro/api/PlatitorTvaRest/v9/tva", "fetchedAt": "2026-11-10T15:14:03.120Z" },
    { "name": "Sursa: portal.just.ro (serviciul web public al Ministerului Justiției)", "url": "http://portalquery.just.ro/query.asmx", "fetchedAt": "2026-11-10T15:14:05.410Z" }
  ],
  "checkedAt": "2026-11-10T15:14:04.002Z"
}
```

### The flags

Plain facts from the cases found in the window. No score, no rating.

| Flag | Raised when |
|---|---|
| `INSOLVENCY_AS_DEBTOR` | An insolvency case (matter *Faliment*) lists the company as **debtor** (*debitor*). |
| `ACTIVE_AS_DEFENDANT` | An **active** case lists the company as defendant (*pârât*, also *intimat pârât*, *apelant pârât*…). |
| `CRIMINAL_CASE_AS_DEFENDANT` | A criminal case lists the company as defendant (*inculpat*), suspect, or party with civil liability (*parte responsabilă civilmente*). As injured party or civil party: counted, no flag. |
| `FISCAL_DISPUTE` | An administrative/tax case (*Contencios administrativ și fiscal*) against a tax authority (ANAF, AJFP, DGRFP, local tax departments…) or about a tax act. |
| `LABOR_DISPUTES` | 3 or more labor cases (*Litigii de muncă*). |
| `NEW_CASE_LAST_90D` | A case registered in the last 90 days. |

**Hearings:** `lastHearingDate` is the last hearing held (before today, or today if the court already recorded a document for it), `nextHearingDate` the first hearing still to come (today without a document yet, or later), and `lastHearingDocument` the type of document the court recorded at the last hearing (e.g. `Hotarare` = judgment, `incheieredesedinta` = hearing minutes). Never the text of the solution.

**Active case:** it has a next hearing (today or later), or no final decision yet (no judgment / final closing among its hearings). A hearing held today that ends in a final decision makes the case inactive the same day. A case without any hearing counts as active only if registered in the last 365 days.

**Role:** `roleOfCompany` keeps only the standard role terms the court recorded for the company (e.g. "Intimat Pârât"). `byRole` puts each case in one bucket: debtor > defendant > claimant > creditor > other.

#### Statuses

| Status | Meaning | Charged |
|---|---|---|
| `OK` | Cases found (or the search was capped, see `truncated`). | yes |
| `NO_CASES` | Every search was complete and no case names the company. | yes |
| `NOT_FOUND` | The CUI is unknown to the ANAF registry. | no |
| `SKIPPED_NATURAL_PERSON` | PFA / II / IF: never searched (GDPR). | no |
| `INVALID_INPUT` | Not a valid CUI. | no |
| `ERROR` | ANAF or portal.just.ro did not answer. Run it again later. | no |

#### Notes

- `legalFormMismatch`: some cases list the company under another legal form (e.g. "SRL" for an SA). They are counted: the name is the same.
- `nearMatchesIgnored`: the search also returned cases of companies with a similar, longer name (e.g. "OMV PETROM MARKETING SRL" when you check OMV PETROM SA). They are **not** counted.
- `ambiguousCommonName`: very common name; the portal returned over 1,000 cases per query and none named this company exactly. The result is `OK` with `caseCount: 0` and `truncated: true`, not `NO_CASES`.
- `caseListLimited`: the company has more than 1,000 cases; the `cases` list holds the 1,000 most recently modified on the portal (`casesTruncatedToLimit: true`, `casesTotal` = all). Counts, flags and monitor changes always use all cases.
- `truncated`: see below.

### How matching works

portal.just.ro has no fiscal codes for parties: companies can only be found **by name**, and names are typed by hand at each court ("SC OMV PETROM SA", "S.C. OMV PETROM S.A.", "O.M.V. PETROM SA", "DANTE INTERNAŢIONAL SA (EMAG)", "OLTCHIM SA PRIN LICHIDATOR…").

1. The name comes from the ANAF registry. The actor searches it **without** "SC" and without the legal form (the portal finds nothing for "… S.R.L." with dots).
2. Each party name in the results is normalized: upper case, no diacritics (ş/ș, ţ/ț), no dots, hyphen = space, "SC"/"SOCIETATEA" removed, anything after a comma, a parenthesis, "PRIN", "CU SEDIUL" or the legal form removed. The portal sometimes returns `?` instead of ș/ț; that is accepted too.
3. A case counts when a party has **exactly** the company's name; the legal form may differ (noted) or be missing.

**Limits of name matching:** a company renamed in the window is only found under its current name; a deregistered company may share its name with a newer one; very common names (e.g. "PARC SRL") may be impossible to tell apart. Check the cases before acting on them.

### Run time and limits

- **One request every 1.1 seconds** to portal.just.ro (no published limit; the actor stays gentle), plus one ANAF request per 100 CUIs.
- Most companies need **one request**. The portal returns at most 1,000 cases per query and drops the rest, so for large companies the actor splits the search by year, then by quarter, up to **20 requests per company** (OMV Petrom, 5 years: 15 requests, ~20 seconds). If a period still has over 1,000 cases, the row gets `truncated: true` and the counts are lower bounds.
- The 20-request cap means that a very large company (for example a bank with over 10,000 cases in the window) can come out with `truncated: true`, and its numbers are then lower bounds.
- **Run time**, from 1.1 seconds per request:

| Companies | Typical (1 request per company) | Worst case (every company hits the 20-request cap) |
|---|---|---|
| 100 | 100 requests, ~2 minutes | 2,000 requests, ~37 minutes |
| 1,000 | 1,000 requests, ~18 minutes | 20,000 requests, ~6 hours 7 minutes |

Real lists sit close to the typical column: only very large companies need more than one request. In monitor mode, later runs need one request per company (the typical column).

- **Timeout:** the default run timeout is 2 hours (about 6,500 requests). If a run stops (timeout, abort or maximum cost), the rows already written stay in the dataset; in monitor mode the companies already checked stay saved, so the next run with the same list continues from there without reporting or charging their changes again. For long lists of large companies, raise the timeout or split the list.
- **Window:** cases registered since 1 January of `sinceYear` (default: 5 years back). Older cases that are still running are not included.
- **Up to 1,000 CUIs per run.** For more, split the list (in monitor mode, each list with its own `monitorId`).
- **Data is as published on portal.just.ro**, which can lag behind the courts. There is no direct link to a case page: the service does not return the portal's internal case id. Search the case number on portal.just.ro.

### Monitor mode

- Turn on **Monitor mode** and give the list a **Monitor name**. The first run outputs every company (baseline, `FIRST_SEEN`).
- Later runs first ask only for cases **modified since the last check**. If none of the company's cases has a new modification time, the company is unchanged (one request, not written, not charged). Otherwise the company is searched in full and only its changes are output: `NEW_CASE`, `CASE_UPDATED` (the portal's modification time changed: new hearing, stage, decision, document…), `FLAG_ADDED`, `FLAG_REMOVED`, `STATUS_CHANGED`.
- `NEW_CASE` and `CASE_UPDATED` show the case **as it is now**, so you see what is new without opening the portal: `stage`, `matter`, `roleOfCompany`, `lastHearingDate`, `nextHearingDate`, `lastHearingDocument`, `active`, and `to` = the portal's modification time. The previous values are not kept (`from` is `null`). Real example (OMV Petrom, 2026-11-11):

```json
{ "type": "CASE_UPDATED", "caseNumber": "2440/105/2024", "court": "Tribunalul PRAHOVA", "stage": "Fond", "matter": "Faliment",
  "roleOfCompany": "Creditor", "lastHearingDate": "2026-10-27", "nextHearingDate": "2027-01-11",
  "lastHearingDocument": "Hotarareintermediara", "active": true, "flag": null, "from": null, "to": "2026-11-11T20:05:46.527",
  "previousCheckAt": "2026-11-11T17:50:01.820Z" }
```

- Flags that change only with time (a case leaving the 90-day window, a hearing date passing) are reported with the company's next case change.
- **A failed check is never a change.** On a source error the company keeps its previous state, gets status `ERROR` and no events.
- **Saved as it goes.** The state is saved during the run (every 10 companies and every minute) and at the end, and it only ever holds successful checks. A run that stops early (timeout, maximum cost, abort, platform restart) keeps the companies already checked.
- **20% guard.** If more than 20% of the companies checked so far fail (judged once at least 10 were checked), the state is not updated from that point on and the status message starts with `WARNING: monitor state NOT saved`. What was saved before stays, so nothing is lost: the rest shows up again next run.
- **The window stays fixed.** A monitor saves its `sinceYear` on the first run and keeps it, so the default (current year minus 5) does not move on 1 January and the New Year brings no extra requests, events or charges. To change the window, set `sinceYear` explicitly: that run re-bases the monitor to the new window and reports only real changes (new cases registered inside both the old and the new window, and updates of known cases); differences caused only by the window (cases entering or leaving it, flag or status changes) are not reported or charged. Rows with events from such a run carry the note `sinceYearChanged`. Later runs keep the new window.
- Keep the same `matters` between monitor runs (a different value triggers a full search).
- State is kept in your key-value store `ro-supplier-litigation-state`, compact: a small index (`state-<monitorId>`) plus one record per company (`state-<monitorId>.<CUI>`) with its status, flags and, for each of its cases, only the case number, a short hash of the court and a short fingerprint of the portal's modification time (~40 bytes per case; a company with 2,300 cases needs ~90 KB). Never other parties. Unchanged companies are not rewritten. States saved by older versions are converted automatically, without events.
- **Size limit:** each company's record is kept under ~8 MB (roughly 200,000 cases for one company). If a company does not fit, the run does not fail: it gets the note `monitorStateFull`, is reported again next run, and the log shows a warning.

### Pricing

**Free during launch.** Right now there are no per-event charges: you pay only the usual Apify platform usage (compute, storage) of your runs, from your own Apify account. The table below is the **planned** pay-per-event pricing. When it starts, Apify notifies users at least 14 days in advance, and from then on platform usage is no longer billed to you separately.

Planned pricing (pay per event):

| Event | Price |
|---|---|
| Company checked | **$0.01** per company ($10.00 per 1,000) |
| Run start | Apify's standard start event, $0.00005 per run |

- **Company checked:** once per company with status `OK` or `NO_CASES` (truncated included) written to your dataset, **however many cases or requests** it takes.
- **Free:** `NOT_FOUND`, `SKIPPED_NATURAL_PERSON`, `INVALID_INPUT`, `ERROR`, duplicates in your list, and unchanged companies in monitor mode.
- **Maximum cost per run.** If you set one, the actor never checks more companies than it can still charge. At the limit it stops cleanly: rows already written stay, and the status message starts with `STOPPED` and says how many were not checked. In monitor mode the companies already checked stay saved, so the next run doesn't report or charge them again.

Examples (planned pricing): 100 companies once = $1.00. A weekly monitor of 500 suppliers costs $5.00 for the baseline, then $0.01 for each company with a change.

### Part of a supplier-check suite

Same CUI list, three angles:

- [Romania Supplier Monitor (ANAF VAT & Inactive Taxpayers)](https://apify.com/nocturntools/ro-supplier-monitor): today's ANAF tax status (VAT registration, inactive taxpayer, deregistration).
- [Romania Supplier Financial Health (ANAF Risk Flags)](https://apify.com/nocturntools/ro-supplier-financial-health): risk flags from the balance sheets ANAF publishes.
- **Romania Supplier Litigation Monitor (portal.just.ro)** (this actor): court cases.

### Privacy and data source

- **Sources:** the public SOAP web service of portal.just.ro (`portalquery.just.ro/query.asmx`, Romanian Ministry of Justice), which the Ministry opened for reuse free of charge with attribution, and ANAF's public taxpayer registry (PlatitorTvaRest v9) for the company name and status. No login, no captcha, no scraping of web pages. Every row cites its sources.
- **Legal entities only.** Natural-person entities (PFA, II, IF) are detected from the registry and never searched: the row holds only the CUI and `SKIPPED_NATURAL_PERSON`.
- **No third parties.** Court cases name other parties, often private persons. The actor reads them only to recognise your company and never outputs, logs or stores them, nor the case subject or the court's solutions. `roleOfCompany` keeps only standard role terms.
- Your CUIs and company names are sent only to ANAF and portal.just.ro. Results stay in your Apify account.
- **Data is as published on portal.just.ro.** The actor doesn't correct or guarantee it.

**Unofficial tool. Source: portal.just.ro public web service (Romanian Ministry of Justice). Not affiliated with or endorsed by the Ministry of Justice or the courts. Not legal advice. Name-based matching may miss or misattribute cases (renamed/deregistered companies, common names).**

### FAQ

**What makes this different?**

- **A whole supplier list at once**, up to 1,000 CUIs, with the same input as the other two supplier checks.
- **Priced per company, not per case.** A company with 2,000 cases costs the same $0.01 as one with 2.
- **Monitor charges only for changes**, and later runs only fetch modified cases.
- **Honest about gaps.** Capped searches, similar names and legal-form mix-ups are reported in `truncated` and `notes`, never hidden.

**Are criminal cases included?**
Yes: only the case number, court, stage and the company's role. A flag is raised only when the company is the defendant, suspect or party with civil liability. Nothing about the persons involved is returned.

**Why does a company have fewer cases than I expected?**
The window starts at `sinceYear`; cases filed under an earlier name, or with a misspelled name, are not found; and some courts publish late. Check `notes` for similar names that were left out.

**Can I get the other parties of a case?**
No. They are often private persons, so the actor never returns them. Search the case number on portal.just.ro.

### Pe scurt, în română

Dosarele din instanțe ale firmelor românești, după CUI, din serviciul web public portal.just.ro (Ministerul Justiției): număr de dosare, calitatea firmei (reclamant, pârât, debitor, creditor), materia, stadiul și semnale factuale (insolvență ca debitor, pârât în dosare active, penal ca inculpat, litigii fiscale și de muncă, dosare noi). Fără scor, doar fapte cu sursa.

- Un rând per firmă; opțional lista dosarelor, fără celelalte părți, fără obiect și fără soluție.
- Modul monitor: rulări programate care raportează doar dosarele noi sau modificate. Fereastra (`sinceYear`) rămâne cea din prima rulare, deci 1 ianuarie nu aduce evenimente sau costuri în plus; dacă dai explicit alt `sinceYear`, monitorul se re-bazează fără să raporteze (sau să taxeze) diferențele care vin doar din schimbarea ferestrei. Starea se salvează pe parcurs: dacă rularea se oprește mai devreme (timeout, cost maxim, oprire manuală), firmele deja verificate rămân salvate, iar rularea următoare continuă de acolo, fără să le raporteze sau să le taxeze din nou.
- PFA / II / IF: nu sunt căutate și nu apar date despre ele (GDPR).
- Potrivirea se face după denumire (portalul nu are CUI pentru părți): firmele redenumite sau cu nume foarte comune pot fi ratate sau confundate.
- Preț: gratuit la lansare (plătești doar consumul de platformă Apify); prețul planificat, anunțat de Apify cu cel puțin 14 zile înainte: 0,01 $ per firmă verificată (OK sau NO_CASES), indiferent de numărul de dosare; restul statusurilor sunt gratuite.
- Folosește și [Romania Supplier Monitor (ANAF VAT & Inactive Taxpayers)](https://apify.com/nocturntools/ro-supplier-monitor) (statut ANAF) și [Romania Supplier Financial Health (ANAF Risk Flags)](https://apify.com/nocturntools/ro-supplier-financial-health) (bilanțuri). Acesta este Romania Supplier Litigation Monitor (portal.just.ro).

Instrument neoficial. Sursa: serviciul web public portal.just.ro (Ministerul Justiției). Nu este afiliat cu Ministerul Justiției sau cu instanțele. Nu reprezintă consultanță juridică.

# Actor input Schema

## `cuis` (type: `array`):

Romanian fiscal codes, one per line. Accepts "RO14399840", "RO 14399840" or "14399840"; 2 to 9 digits with a valid control digit. The company name is taken from the ANAF registry and searched on portal.just.ro. Invalid entries get INVALID_INPUT; natural persons (PFA / II / IF) are skipped and never searched. Duplicates are checked once. Maximum 1,000 per run.

## `sinceYear` (type: `integer`):

Only cases registered from 1 January of this year are searched. Default: the current year minus 5. In monitor mode, empty = the window saved by the monitor's first run (it does not move on 1 January); a different value re-bases the monitor without reporting differences caused only by the window change. Older cases that are still running are not included. A longer window means more requests for large companies (the portal returns at most 1,000 cases per query).

## `matters` (type: `array`):

Keep only cases of these matters (counts, flags and case list). Empty = all matters, criminal cases included (only the case and the company's role, no other details).

## `includeCaseList` (type: `boolean`):

Add one entry per case (number, court, matter, stage, the company's role, last and next hearing). At most 1,000 cases per company, the most recently modified; counts and flags always use all cases. Off = only counts, flags and notes per company. The other parties, the subject and the solutions are never included.

## `monitorMode` (type: `boolean`):

Compare with the previous monitor run and output only companies with changes: a new case, a case updated on the portal (new hearing, stage, decision…), a flag that appeared or disappeared, or a status change. The first run outputs everything (baseline). Later runs first ask the portal only for cases modified since the last check, so unchanged companies take one quick request. Unchanged companies are not written and not charged.

## `monitorId` (type: `string`):

Monitor mode only. Name of the saved state, so you can monitor several lists. Letters, digits and dashes, max. 40 characters. Stored in your key-value store "ro-supplier-litigation-state" (per company only case numbers, courts and modification times; never other parties; kept under ~8 MB).

## Actor input object example

```json
{
  "cuis": [
    "RO18189442",
    "1475261",
    "49999996"
  ],
  "matters": [],
  "includeCaseList": true,
  "monitorMode": false,
  "monitorId": "default"
}
```

# Actor output Schema

## `results` (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 = {
    "cuis": [
        "RO18189442",
        "1475261",
        "49999996"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nocturntools/ro-supplier-litigation").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 = { "cuis": [
        "RO18189442",
        "1475261",
        "49999996",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("nocturntools/ro-supplier-litigation").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 '{
  "cuis": [
    "RO18189442",
    "1475261",
    "49999996"
  ]
}' |
apify call nocturntools/ro-supplier-litigation --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nocturntools/ro-supplier-litigation"
        }
    }
}
```

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/Thww2ShbINZZAmOG7/builds/2PTj9NOFCrgb28lRt/openapi.json
