# Romania Company Due Diligence (CUI) (`apnoda/romania-dd-bundle`) Actor

One-call factual due diligence on a Romanian company by CUI: identity & fiscal standing (ANAF), published tax arrears, EU/OFAC/UN/UK/SECO sanctions screening, litigation & insolvency (portal.just.ro), and procurement history (SEAP). No score, rating, or recommendation. CUI-keyed; no name search.

- **URL**: https://apify.com/apnoda/romania-dd-bundle.md
- **Developed by:** [Apnoda](https://apify.com/apnoda) (community)
- **Categories:** Developer tools, MCP servers, AI
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $200.00 / 1,000 due-diligence report completed (primary)s

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Due-Diligence Firme România (CUI), Raport Factual Consolidat

🇷🇴 [Română](#română) · 🇬🇧 [English](#english)

---

### Română

**Tot ce e public despre o firmă românească, într-un singur apel, factual, fără scor.** Dai un CUI, primești o vedere consolidată de due-diligence: identitate și situație fiscală (ANAF), restanțe pe lista publică, screening de sancțiuni (UE FSF / OFAC / ONU / UK / SECO), expunere la litigii și insolvență (portal.just.ro) și istoric de achiziții publice (SEAP). Input exclusiv CUI (fără căutare după nume), nativ-MCP, plată pe eveniment. **Agregare factuală, niciun scor, rating sau recomandare:** tool-ul livrează faptele cu prospețime per semnal, concluzia o trage cititorul.

#### De ce „fără scor”

Un scor 0–100 pe o **firmă numită** este o prelucrare care intră sub incidența pragului DPIA (Art. 35) și se apropie de expunerea la defăimare, iar noi suntem operatorul de date. Am ales deliberat să **nu** emitem un verdict: pachetul surfacelază datele deja minimizate ale celor patru surse, cu toate avertismentele, și lasă agentul/analistul să raționeze. Pentru un cumpărător din UE, GDPR-nativ, „date factuale profunde despre România, fără cutie neagră” este o poziție **defensabilă**, nu doar cea prudentă.

#### Ce compune acest Actor

Un singur tool, **`due_diligence(cui)`**, rezolvă intern denumirea legală din CUI și compune șase semnale, fiecare cu propria prospețime (`as_of` / `is_stale`) și fiecare **degradând independent** (un semnal indisponibil nu prăbușește raportul):

| Semnal | Sursă | Ce conține |
|---|---|---|
| **Identitate & fiscal** | ANAF | denumire, formă juridică, CAEN + etichetă, stare înregistrare, **inactiv fiscal**, plătitor TVA, TVA radiat, **radiată** recent |
| **Restanțe** | Lista publică ANAF | `arrears_on_published_list` (trei stări), suma în lei, observații |
| **Sancțiuni** | UE FSF + OFAC + ONU + UK + SECO | `status` (CLEAR / POSSIBLE_MATCH / MATCH / UNAVAILABLE), potriviri scorate, liste ecranate + prospețime, disclaimer |
| **Litigii** | portal.just.ro | total dosare, **câte penale**, `truncated`, cele mai recente dosare (instanță, materie, stadiu), `quota_exceeded` |
| **Insolvență** | portal.just.ro | `confidence` (high/medium/low/none, **puterea potrivirii** nume/rol-debitor/județ, NU o determinare), `reason`, tip procedură (faliment/reorganizare), stadiu curent, `is_closed`, dosare (doar metadata structurată), `truncated` |
| **Achiziții publice** | SEAP / SICAP | furnizor public?, nr. atribuiri, valoare RON, cumpărători distincți, CPV distincte, prima/ultima atribuire, **ani activi (întindere calendaristică)**, activ în ultimele 12 luni |

Fiecare apel duce și un `disclaimers[]` și un `generated_at`. Datele de bază ale fiecărei surse sunt publice, diferența acestui Actor este **join-ul după CUI, într-un singur tur, apelabil de un agent, cu prospețime onestă per semnal și fără verdict editorial.**

#### Cele patru reguli cardinale (altfel datele te induc în eroare)

| Câmp | NU înseamnă | Înseamnă |
|---|---|---|
| `tax_standing.arrears_on_published_list: null` | „fără restanțe” | lista publică **nu e încărcată**, necunoscut. Doar `false` = listă încărcată + firmă absentă. |
| `sanctions.status: UNAVAILABLE` | „curat” | listele **nu au fost încărcate**, firma **nu** a fost ecranată. Doar `CLEAR` = ecranat, fără potrivire. |
| `litigation.available: false` | „fără litigii” | sursa **nu a putut fi verificată** (indisponibilă / cotă epuizată). `0` cazuri cu `available:false` ≠ zero litigii. |
| `procurement.is_public_supplier: null` | „nu e furnizor public” | snapshot-ul SEAP **nu e încărcat**, necunoscut. Doar `false` = snapshot încărcat + fără contracte. |

Plus: un `POSSIBLE_MATCH` / `MATCH` la sancțiuni este o **similaritate de nume de verificat manual**, nu o determinare; un dosar `is_penal` este un **fapt procedural neutru** (materie penală), nu o constatare de vinovăție; **insolvența** este punctată pe încredere (`confidence` = puterea potrivirii nume/rol-debitor/județ), NU o determinare că firma este în insolvență, iar `available:false` / `confidence:none` NU înseamnă „fără insolvență”; `truncated:true` = listă **incompletă**; `years_active` este o **întindere calendaristică** (ultimul an − primul an + 1), nu ani de activitate continuă. Toate acestea sunt formulate în output și în SOP-ul de prompt, niciodată „fraudă”/„suspect”/„ilegal”.

#### De ce să folosești acest Actor (moat-ul)

**Un tool global de KYB nu acoperă România.** Pentru o firmă românească, un generalist global întoarce sancțiuni + eventual un ciot OpenCorporates: și **nimic altceva** (jurisdicțiile neacoperite „pot întoarce zero rezultate”). apnoda întoarce exact ce ei nu pot: **ANAF + lista de restanțe + dosarele portal.just.ro + istoricul SEAP**, join-uite sub un singur CUI, cu prospețime onestă. Nu suntem un generalist mai ieftin, suntem **specialistul de adâncime pe România**.

Trei profiluri:

- **Dezvoltatori de agenți AI**: nativ-MCP din prima zi. Un singur apel (`due_diligence`) îți dă vederea consolidată; SOP-ul de prompt o sintetizează cu toate avertismentele.
- **Constructori de instrumente de due-diligence**: patru surse publice (șase semnale), fiecare cu portalul ei, condensate într-un singur răspuns tipat și stabil, după CUI.
- **Conformitate, KYC/AML și jurnaliști**: triezi expunerea unei contrapărți (fiscal + sancțiuni + instanțe + achiziții) într-un singur apel, cu o urmă de prospețime pe care o poți păstra ca dovadă.

#### Utilizare MCP

```json
{
  "mcpServers": {
    "romania-dd": {
      "url": "https://mcp.apify.com?tools=apnoda/romania-dd-bundle"
    }
  }
}
````

| Primitivă | Nume | Ce face |
|---|---|---|
| **Tool** | `due_diligence` | `{ cui }` → vederea factuală consolidată (cele 6 semnale + prospețime + disclaimere). Acceptă `"14399840"`, `"RO14399840"` sau `"RO 14399840"`; opțional `max_acceptable_lag_minutes` (prag de prospețime, niciodată un eșec dur). |
| **Prompt** | `due-diligence-firma` (RO) | SOP în limba română: apelează `due_diligence(cui)` o dată, apoi sintetizează un rezumat care duce **fiecare** avertisment și **nu** emite verdict. |
| **Prompt** | `company-due-diligence` (EN) | Alias în engleză al aceluiași SOP. |

Apoi întrebi agentul, de exemplu: *„Fă un due-diligence pe firma cu CUI 14399840, identitate, restanțe, sancțiuni, litigii, insolvență și achiziții, fără verdict.”* Agentul alege tool-ul, îl apelează o dată și sintetizează.

> 🤖 **Pregătit pentru plăți agentice:** plăți x402 (USDC pe Base) sunt suportate pentru Actorii cu plată-pe-eveniment, funcție **experimentală** a platformei Apify.

#### Utilizare Apify (non-MCP / dataset)

Rulaj standard pentru un **lot** de firme: pui CUI-urile în `cuis` (până la **100** per rulaj), pornești, colectezi câte o înregistrare plată per firmă rezolvată din dataset.

```json
{
  "cuis": ["14399840", "RO 38150891"],
  "max_acceptable_lag_minutes": 1440
}
```

Două vederi pre-definite: **Overview** (coloanele go/no-go scanabile) și **CSV export** (toate câmpurile scalare). Vederea de dataset este plată; **pachetul complet, imbricat** (cu cele mai recente dosare, potrivirile de sancțiuni și prospețimea per semnal) îl întoarce tool-ul MCP.

#### Ce primești (exemplu prescurtat, firmă fără semnale negative)

```json
{
  "cui": "14399840",
  "generated_at": "2026-06-20T09:00:00.000Z",
  "source": "live",
  "cache_age_minutes": 0,
  "identity": {
    "resolved": true,
    "denumire": "EXEMPLU COMPANY SRL",
    "is_natural_person": false,
    "cod_caen": "6201",
    "caen_label": "Activități de realizare a soft-ului la comandă",
    "forma_juridica": "Societate cu raspundere limitata",
    "stare_inregistrare": "INREGISTRAT",
    "fiscal_inactive": false,
    "vat_payer": true,
    "recently_radiata": false,
    "as_of": "2026-06-20T06:00:00.000Z",
    "is_stale": false
  },
  "tax_standing": { "arrears_on_published_list": false, "arrears_amount_lei": null, "as_of": "2026-03-31T00:00:00.000Z", "is_stale": false },
  "sanctions": {
    "status": "CLEAR",
    "matches": [],
    "screened_against": [
      { "list": "eu_fsf", "as_of": "2026-06-19T03:00:00.000Z", "is_stale": false },
      { "list": "ofac_sdn", "as_of": "2026-06-19T03:00:00.000Z", "is_stale": false },
      { "list": "ofac_cons", "as_of": "2026-06-19T03:00:00.000Z", "is_stale": false },
      { "list": "un_sc", "as_of": "2026-06-19T03:00:00.000Z", "is_stale": false },
      { "list": "uk_hmt", "as_of": "2026-06-19T03:00:00.000Z", "is_stale": false },
      { "list": "ch_seco", "as_of": "2026-06-19T03:00:00.000Z", "is_stale": false }
    ],
    "is_stale": false,
    "disclaimer": "Screening result, not legal advice. Only the official source list (the EU Official Journal, the UK Sanctions List, OFAC, the UN, or SECO) is authentic. Verify any match against the official list. A POSSIBLE_MATCH is a name-similarity flag for human verification, never a determination that the entity is on a sanctions list."
  },
  "litigation": { "available": true, "total_cases": 0, "penal_case_count": 0, "truncated": false, "recent_cases": [], "is_stale": false, "quota_exceeded": false },
  "procurement": {
    "is_public_supplier": true, "total_awards": 42, "total_value_ron": 7350000,
    "distinct_buyer_count": 9, "first_award_date": "2019-04-12", "last_award_date": "2026-02-18",
    "years_active": 8, "is_active_last_12mo": true, "is_stale": false
  },
  "disclaimers": [
    "Factual aggregation of public-source data: not a score, rating, or recommendation, and not legal or financial advice.",
    "A null/UNAVAILABLE signal means \"not loaded / could not be checked\", NOT \"clean\". Never read an absent arrears, sanctions, or litigation signal as a clear.",
    "A penal (is_penal) case is a neutral procedural fact (the matter is criminal-law), not a finding of guilt.",
    "years_active is a CALENDAR span (last_award_year − first_award_year + 1), not a count of continuously-active years.",
    "Each signal carries its own as_of / is_stale: the sources refresh on different cadences; the bundle generated_at is not a single freshness."
  ]
}
```

> **Notă:** valorile `disclaimer` și `disclaimers[]` din răspuns sunt returnate **în limba engleză**, verbatim de la orchestrator (nu sunt localizate); `screened_against[]` reflectă listele efectiv încărcate la momentul compunerii.

#### Comparație cu alternativele

| | apnoda romania-dd-bundle | Tool global de KYB + scor (MCP) | Verificare manuală (portaluri oficiale) | Suite enterprise |
|---|---|---|---|---|
| Acoperire România | **adâncă** (ANAF + restanțe + instanțe + SEAP) | sancțiuni + eventual ciot OpenCorporates; **„zero” pe firme RO** | aceleași surse, dar manual | variabilă, rar RO-nativă |
| Intrare | **CUI** (nativ RO); numele rezolvat intern | nume / număr | nume, manual | nume / ID |
| Ieșire | **factuală, fără scor** | scor 0–100 | date brute | scor + dosar |
| Interfață | **nativ-MCP** + dataset | MCP / API | formulare web | portal / API enterprise |
| Prospețime | per semnal (`as_of` / `is_stale`) | variabilă | live la sursă | continuă |
| Preț | **$0.20 / raport**, fără abonament | ~$0.10–0.50 / raport | gratuit, dar lent/manual | contract anual, $$$$ |
| Potrivit pentru | DD de adâncime pe contrapărți RO | screening global, scorat | verificări ad-hoc | departamente mari de compliance |

**Onest:** acest Actor **nu înlocuiește** un program complet KYC/AML și nu acoperă firme din afara României. Acoperă cele patru surse publice de mai sus, nu PEP, nu adverse media, nu ONRC (administratori / capital / beneficiari reali), nu situații financiare. Folosește-l ca stratul de adâncime pe România, nu ca unic control.

#### Prețuri și calculator de costuri

Model **plată-pe-eveniment** (PPE), fără abonament, fără chirie:

- **Raport completat** (`due_diligence_completed`): **$0.20**, evenimentul principal, taxat o dată per firmă (CUI) pentru care se întoarce un raport, fie servit din cache-ul de 24h, fie compus proaspăt.
- **Pornire Actor** (`actor_start`): **$0.01**, o dată per rulaj / pornire la rece în standby. În uz MCP standby „cald”, rapoartele succesive nu re-taxează pornirea.
- Un CUI care nu rezolvă la nicio firmă (NOT\_FOUND), un CUI invalid sau o eroare upstream **nu se taxează**.

| Scenariu | Calcul | Total |
|---|---|---|
| Verificare unică a unei contrapărți | $0.01 + 1 × $0.20 | **$0.21** |
| Triere a 50 de contrapărți (un rulaj dataset) | $0.01 + 50 × $0.20 | **$10.01** |
| 200 de contrapărți (o sesiune MCP standby „caldă”) | $0.01 + 200 × $0.20 | **$40.01** |

Un rulaj **dataset/task este limitat la 100 CUI** (o pornire de $0.01). Pentru volume mai mari: fie mai multe rulaje dataset (câte $0.01 fiecare), fie o singură sesiune MCP standby „caldă” (o pornire, multe rapoarte). Costurile de platformă/calcul sunt absorbite în prețul evenimentului, niciodată taxate separat. **Cache-ul de 24h per CUI face un re-apel rapid, dar nu gratuit:** fiecare raport returnat se taxează identic, din cache sau proaspăt (dovada „verificat” este livrabilul).

> ⏱️ **Primul apel pe o firmă „rece” este mai lent**, declanșează o căutare live de litigii (SOAP) + rezolvarea CUI → denumire + o tragere din cota zilnică. Apelurile următoare (24h) sunt servite din cache.

#### Limitări cunoscute

Sincer, de la început:

- **Fără scor / rating / verdict**: agregare factuală. Tu (sau agentul) tragi concluzia. (Alegere de produs **și** gardă GDPR, vezi „De ce fără scor”.)
- **Doar firme din România, doar după CUI**: fără căutare după nume (gardă de re-identificare), fără jurisdicții non-RO.
- **Fără ONRC** (administratori, capital social, beneficiari reali), **fără situații financiare**, **fără PEP / adverse media**: declarate în afara scopului, nu omise tacit.
- **Sancțiuni la nivel de persoană juridică**, potrivire de nume pentru verificare: niciodată o determinare.
- **Litigii plafonate la 1000 de dosare** per firmă (plafonul sursei); `truncated:true` semnalează limita.
- **Prospețime heterogenă**: fiecare semnal are propriul `as_of` / `is_stale`; `generated_at` al pachetului nu este o singură prospețime. `max_acceptable_lag_minutes` poate strânge (niciodată lărgi) ferestrele.

#### Sursa datelor și aspecte legale

Acest Actor nu extrage nicio sursă direct, compune substraturile deja ingestate ale celor patru Actori-surori:

- **ANAF** (identitate/fiscal + lista publică de restanțe): date publice prin serviciul ANAF.
- **[portal.just.ro](https://portal.just.ro)**: serviciul public al instanțelor (interogări prin serviciul SOAP `portalquery.just.ro`); metadatele dosarelor sunt publice prin statut; părțile persoane fizice sunt **pseudonimizate prin proiectare** (orchestrator-side).
- **Sancțiuni**: **UE FSF** (*Contains EU Financial Sanctions Files data © European Union, reused under Commission Decision 2011/833/EU; modified.*), **OFAC** (operă a Guvernului SUA, domeniu public), **ONU SC** (material ONU), **UK** (UK Sanctions List, FCDO; Crown copyright, reutilizabil sub Open Government Licence v3.0), **SECO** (lista consolidată elvețiană, State Secretariat for Economic Affairs; date oficiale publice). Doar lista oficială a sursei (Jurnalul Oficial al UE, UK Sanctions List, OFAC, ONU sau SECO) este autentică, verifică orice potrivire împotriva listei oficiale.
- **SEAP / SICAP**: achiziții publice, date publice.

#### Confidențialitate & date personale

apnoda-daas este operatorul de date; Apify, Cloudflare și Hetzner sunt persoane împuternicite (Art. 28). Controalele sunt arhitecturale, nu improvizate per sursă:

- **Doar input CUI**: fără căutare după nume (garda de re-identificare GDPR). Denumirea legală este rezolvată intern.
- **Niciun DPIA propriu și nicio dată personală nouă**: pachetul compune date deja minimizate, în spatele DPIA-urilor existente (portal.just.ro; sancțiuni). Raționamentul „de ce fără DPIA nou” este consemnat explicit în ROPA (agregare + date Art. 10 este ea însăși un declanșator de evaluat, nu de presupus). **Contingență:** în clipa în care s-ar adăuga un scor, declanșatorul Art. 35 se aprinde și un DPIA devine obligatoriu.
- **Denumirea legală servită** include numele înregistrat al unei PFA / persoane fizice autorizate: afișat ca **dată de registru public**; pachetul **nu** servește adresa.
- **Părțile persoane fizice din litigii sunt pseudonimizate**; persoanele juridice, PFA/ÎI/IF și instituțiile publice trec cu numele lor.
- **Sancțiuni**: surfacelate ca „posibilă potrivire de verificat”, niciodată o determinare; instantaneu înlocuit integral la fiecare reîmprospătare.
- **Cereri ale persoanelor vizate (DSR):** scrie la `privacy@apnoda.com`: răspuns în 30 de zile (Art. 12(3) GDPR).
- **Notă publică de confidențialitate:** [apnoda.com/privacy](https://apnoda.com/privacy).

#### Fiabilitate

- **Mediat prin `/compute`, cache-first**; acest Actor nu citește niciun Postgres și nu deține niciun secret de sursă: o thin-proxy peste orchestrator.
- **Degradare soft per semnal:** un semnal indisponibil (sancțiuni neîncărcate, cotă de litigii epuizată) se marchează onest **în răspunsul 200** (`UNAVAILABLE` / `available:false` + `quota_exceeded:true`): **nu** prăbușește raportul și **nu** devine o eroare de tool.
- Coduri de eroare la nivel de tool: `COMPUTE_UNREACHABLE` (pană tranzitorie, reîncearcă în ~30s); `COMPUTE_UNAVAILABLE` (magazinul de date al orchestratorului temporar inaccesibil, reîncearcă, raportează dacă persistă); `COMPUTE_BAD_REQUEST` (eroare de integrare, **permanentă**, raportează, reîncercarea nu ajută); `INVALID_INPUT` / `NOT_FOUND` (CUI invalid / firmă inexistentă în ANAF, **netaxate**); `IDENTITY_UNVERIFIED` (sursa de identitate nu a putut fi contactată, deci existența NU a fost verificată, diferit de `NOT_FOUND`, reîncearcă, **netaxat**).
- **Infrastructura este permanentă**: backup-uri regulate, criptate, în Cloudflare R2; exercițiu DR periodic. Niciodată „șterge-și-reconstruiește”.

#### Transparență privind utilizarea platformei

Calea MCP rulează în modul standby Apify.

- **Memorie standby:** 1024 MB (vârf RSS măsurat 2026-06-20: **66 MB**; un proxy `/compute` subțire, deci 1024 MB lasă marjă amplă).
- **Profil de latență warm (măsurat împotriva standby-ului de producție):**
  - apel cache-hit (`due_diligence`, CUI cald): **~265 ms**
  - apel proaspăt (CUI rece, SOAP litigii live): **~4–5 s** (apoi în cache 24h)
  - pornire la rece (primul apel după inactivitate): **~5–7 s**
- **Economie CU:** la 1024 MB, standby-ul cald consumă ~1 CU/oră; costul de calcul per raport e dominat de coada de inactivitate de după apel, nu de apelul de ~265 ms. Costurile de platformă/calcul sunt absorbite în prețul per-eveniment, fără taxe ascunse.

#### Suport

- **Probleme sau întrebări:** folosește formularul de contact din pagina Actorului din Apify Store.
- **Alți Actori:** răsfoiește [profilul apnoda](https://apify.com/apnoda): pachetul se cuplează natural cu cei patru Actori-surori (ANAF, portal.just.ro, sancțiuni, SEAP), fiecare apelabil și separat.

#### Întrebări frecvente (FAQ)

**De ce nu există un scor de risc?**
Pentru că un scor 0–100 pe o firmă numită este profilare ce trece pragul DPIA (Art. 35) + expunere la defăimare (suntem operatorul). Livrăm faptele, cu toate avertismentele; concluzia o tragi tu.

**De ce doar CUI, fără căutare după nume?**
Garda de re-identificare GDPR: input-ul după nume ar transforma serviciul într-un motor de căutare de persoane. CUI-ul identifică o persoană juridică; denumirea e rezolvată intern.

**Un `MATCH` la sancțiuni înseamnă că firma e sancționată?**
Nu, o similaritate de nume ridicată față de o intrare oficială, de verificat manual. Verifică `matches[]` împotriva sursei oficiale înainte de a acționa.

**`arrears_on_published_list: null` înseamnă „fără restanțe”?**
Nu, înseamnă că lista publică nu e încărcată în acel moment. Doar `false` (listă încărcată + firmă absentă) înseamnă „nu apare pe listă”.

**Ce e `years_active`?**
Întinderea calendaristică (ultimul an − primul an + 1), nu ani de activitate continuă, o firmă cu atribuiri doar în 2018 și 2024 are `years_active = 7`.

**Datele sunt în timp real?**
Reflectă cache-ul nostru de 24h per CUI, re-compus la cerere. Fiecare semnal poartă propriul `as_of` / `is_stale`; `max_acceptable_lag_minutes` cere o reîmprospătare.

**Pot screena o persoană fizică / un administrator?**
Nu, v1 lucrează la nivel de persoană juridică, după CUI. ONRC (administratori, beneficiari reali) e rezervat ca tier premium viitor, nu e în v1.

**Cum controlez cheltuielile?**
Plată pe eveniment, pe raport returnat, fără abonament. Setezi limite per-rulaj și lunare în Apify Console. CUI-urile NOT\_FOUND / invalide nu se taxează.

***

### English

**Everything public about a Romanian company, in one call, factual, no score.** Give a CUI, get a consolidated due-diligence view: identity & fiscal standing (ANAF), the published tax-arrears list, sanctions screening (EU FSF / OFAC / UN / UK / SECO), court-litigation exposure and insolvency (portal.just.ro), and public-procurement history (SEAP). CUI-only input (no name search), MCP-native, pay-per-event. **Factual aggregation, no score, rating, or recommendation:** the tool delivers the facts with per-signal freshness; the reader draws the conclusion.

#### Why "no score"

A 0–100 score on a *named company* is processing that crosses the DPIA threshold (Art. 35) and edges into defamation exposure, and we are the data controller. We deliberately do **not** emit a verdict: the bundle surfaces the four sources' already-minimized data, with every caveat, and lets the agent/analyst reason. For an EU, GDPR-native buyer, "deep factual Romanian data, no black box" is a *defensible* stance, not merely the safe one.

#### What this Actor composes

A single tool, **`due_diligence(cui)`**, resolves the legal name from the CUI internally and composes six signals, each with its own freshness (`as_of` / `is_stale`) and each **degrading independently** (one unavailable signal never collapses the report):

| Signal | Source | What it carries |
|---|---|---|
| **Identity & fiscal** | ANAF | legal name, legal form, CAEN + label, registration state, **fiscally inactive**, VAT payer, VAT deregistered, recently **struck off** |
| **Tax arrears** | ANAF published list | `arrears_on_published_list` (three-state), amount in lei, observations |
| **Sanctions** | EU FSF + OFAC + UN + UK + SECO | `status` (CLEAR / POSSIBLE\_MATCH / MATCH / UNAVAILABLE), scored matches, screened lists + freshness, disclaimer |
| **Litigation** | portal.just.ro | total cases, **how many penal**, `truncated`, the most recent cases (court, matter, stage), `quota_exceeded` |
| **Insolvency** | portal.just.ro | `confidence` (high/medium/low/none, **match strength** by name/debtor-role/county, NOT a determination), `reason`, procedure type (faliment/reorganizare), current stage, `is_closed`, cases (structured metadata only), `truncated` |
| **Procurement** | SEAP / SICAP | public supplier?, award count, RON value, distinct buyers, distinct CPV, first/last award, **years active (calendar span)**, active in last 12 months |

Every call also carries a `disclaimers[]` and a `generated_at`. Each source's base data is public, this Actor's difference is **the CUI-keyed join, in one round-trip, agent-callable, with honest per-signal freshness and no editorial verdict.**

#### The four cardinal rules (or the data misleads you)

| Field | Does NOT mean | Means |
|---|---|---|
| `tax_standing.arrears_on_published_list: null` | "no arrears" | the published list is **not loaded**, unknown. Only `false` = list loaded + company absent. |
| `sanctions.status: UNAVAILABLE` | "clear" | the lists were **not loaded**, the company was **not** screened. Only `CLEAR` = screened, no match. |
| `litigation.available: false` | "no litigation" | the source **could not be checked** (unavailable / quota exhausted). `0` cases with `available:false` ≠ zero litigation. |
| `procurement.is_public_supplier: null` | "not a public supplier" | the SEAP snapshot is **not loaded**, unknown. Only `false` = snapshot loaded + no awards on record. |

Plus: a sanctions `POSSIBLE_MATCH` / `MATCH` is a **name-similarity flag for human verification**, not a determination; an `is_penal` case is a **neutral procedural fact** (a penal-law matter), not a finding of guilt; **insolvency** is confidence-scored (`confidence` = match strength by name/debtor-role/county), NOT a determination that the company is in insolvency, and `available:false` / `confidence:none` does NOT mean "no insolvency"; `truncated:true` = an **incomplete** list; `years_active` is a **calendar span** (last year − first year + 1), not continuously-active years. All of this is phrased in the output and in the prompt SOP, never "fraud"/"suspect"/"illegal".

#### Why use this Actor (the moat)

**A global KYB tool does not cover Romania.** For a Romanian company, the global generalist returns sanctions + maybe an OpenCorporates stub: and **nothing else** (uncovered jurisdictions "may return zero hits"). apnoda returns exactly what they can't: **ANAF + the arrears list + portal.just.ro cases + the SEAP history**, joined under one CUI, with honest freshness. We're not a cheaper generalist, we're the **Romania-depth specialist**.

Three buyer profiles:

- **AI-agent developers**: MCP-native from day one. One call (`due_diligence`) returns the consolidated view; the prompt SOP synthesizes it carrying every caveat.
- **Due-diligence tool builders**: four public sources (six signals), each with its own portal, collapsed into one typed, stable response, keyed by CUI.
- **Compliance, KYC/AML, and journalists**: vet a counterparty's exposure (fiscal + sanctions + courts + procurement) in one call, with a freshness trail you can keep as evidence.

#### MCP-first usage

```json
{
  "mcpServers": {
    "romania-dd": {
      "url": "https://mcp.apify.com?tools=apnoda/romania-dd-bundle"
    }
  }
}
```

| Primitive | Name | What it does |
|---|---|---|
| **Tool** | `due_diligence` | `{ cui }` → the consolidated factual view (the 6 signals + freshness + disclaimers). Accepts `"14399840"`, `"RO14399840"`, or `"RO 14399840"`; optional `max_acceptable_lag_minutes` (a freshness ceiling, never a hard fail). |
| **Prompt** | `due-diligence-firma` (RO) | Romanian SOP: call `due_diligence(cui)` once, then synthesize a summary that carries **every** caveat and emits **no** verdict. |
| **Prompt** | `company-due-diligence` (EN) | English alias of the same SOP. |

Then ask your agent, e.g.: *"Run due diligence on the company with CUI 14399840, identity, arrears, sanctions, litigation, insolvency, and procurement, no verdict."* The agent picks the tool, calls it once, and synthesizes.

> 🤖 **Agentic-payments ready:** x402 payments (USDC on Base) are supported for pay-per-event Actors, an **experimental** Apify-platform feature.

#### Apify usage (non-MCP / dataset)

Standard run for a **batch** of companies: put the CUIs in `cuis` (up to **100** per run), start, collect one flat record per resolved company from the dataset.

```json
{
  "cuis": ["14399840", "RO 38150891"],
  "max_acceptable_lag_minutes": 1440
}
```

Two pre-built views: **Overview** (the scannable go/no-go columns) and **CSV export** (every scalar field). The dataset view is flat; the **full nested bundle** (with recent cases, sanctions matches, and per-signal freshness) is returned by the MCP tool.

#### What you get (abbreviated example, a company with no negative signals)

```json
{
  "cui": "14399840",
  "generated_at": "2026-06-20T09:00:00.000Z",
  "source": "live",
  "cache_age_minutes": 0,
  "identity": {
    "resolved": true,
    "denumire": "EXEMPLU COMPANY SRL",
    "is_natural_person": false,
    "cod_caen": "6201",
    "caen_label": "Activități de realizare a soft-ului la comandă",
    "forma_juridica": "Societate cu raspundere limitata",
    "stare_inregistrare": "INREGISTRAT",
    "fiscal_inactive": false,
    "vat_payer": true,
    "recently_radiata": false,
    "as_of": "2026-06-20T06:00:00.000Z",
    "is_stale": false
  },
  "tax_standing": { "arrears_on_published_list": false, "arrears_amount_lei": null, "as_of": "2026-03-31T00:00:00.000Z", "is_stale": false },
  "sanctions": {
    "status": "CLEAR",
    "matches": [],
    "screened_against": [
      { "list": "eu_fsf", "as_of": "2026-06-19T03:00:00.000Z", "is_stale": false },
      { "list": "ofac_sdn", "as_of": "2026-06-19T03:00:00.000Z", "is_stale": false },
      { "list": "ofac_cons", "as_of": "2026-06-19T03:00:00.000Z", "is_stale": false },
      { "list": "un_sc", "as_of": "2026-06-19T03:00:00.000Z", "is_stale": false },
      { "list": "uk_hmt", "as_of": "2026-06-19T03:00:00.000Z", "is_stale": false },
      { "list": "ch_seco", "as_of": "2026-06-19T03:00:00.000Z", "is_stale": false }
    ],
    "is_stale": false,
    "disclaimer": "Screening result, not legal advice. Only the official source list (the EU Official Journal, the UK Sanctions List, OFAC, the UN, or SECO) is authentic. Verify any match against the official list. A POSSIBLE_MATCH is a name-similarity flag for human verification, never a determination that the entity is on a sanctions list."
  },
  "litigation": { "available": true, "total_cases": 0, "penal_case_count": 0, "truncated": false, "recent_cases": [], "is_stale": false, "quota_exceeded": false },
  "procurement": {
    "is_public_supplier": true, "total_awards": 42, "total_value_ron": 7350000,
    "distinct_buyer_count": 9, "first_award_date": "2019-04-12", "last_award_date": "2026-02-18",
    "years_active": 8, "is_active_last_12mo": true, "is_stale": false
  },
  "disclaimers": [
    "Factual aggregation of public-source data: not a score, rating, or recommendation, and not legal or financial advice.",
    "A null/UNAVAILABLE signal means \"not loaded / could not be checked\", NOT \"clean\". Never read an absent arrears, sanctions, or litigation signal as a clear.",
    "A penal (is_penal) case is a neutral procedural fact (the matter is criminal-law), not a finding of guilt.",
    "years_active is a CALENDAR span (last_award_year − first_award_year + 1), not a count of continuously-active years.",
    "Each signal carries its own as_of / is_stale: the sources refresh on different cadences; the bundle generated_at is not a single freshness."
  ]
}
```

> **Note:** the `disclaimer` / `disclaimers[]` strings are fixed and returned **verbatim in English** (not localized); `screened_against[]` reflects whichever official lists were loaded at compose time.

#### How it compares

| | apnoda romania-dd-bundle | Global KYB + score tool (MCP) | Manual check (official portals) | Enterprise suites |
|---|---|---|---|---|
| Romania coverage | **deep** (ANAF + arrears + courts + SEAP) | sanctions + maybe an OpenCorporates stub; **"zero" on RO companies** | same sources, but manual | varies, rarely RO-native |
| Input | **CUI** (RO-native); name resolved internally | name / number | name, manual | name / ID |
| Output | **factual, no score** | 0–100 score | raw data | score + dossier |
| Interface | **MCP-native** + dataset | MCP / API | web forms | portal / enterprise API |
| Freshness | per signal (`as_of` / `is_stale`) | varies | live at source | continuous |
| Price | **$0.20 / report**, no subscription | ~$0.10–0.50 / report | free, but slow/manual | annual contract, $$$$ |
| Best for | deep DD on RO counterparties | global, scored screening | one-off ad-hoc checks | large compliance departments |

**Honest positioning:** this Actor **does not replace** a full KYC/AML program and does not cover companies outside Romania. It covers the four public sources above, not PEPs, not adverse media, not ONRC (administrators / capital / beneficial owners), not financial statements. Use it as the Romania-depth layer, not your only control.

#### Pricing and cost calculator

**Pay-per-event** (PPE) model, no subscription, no rental:

- **Report completed** (`due_diligence_completed`): **$0.20**, the primary event, billed once per company (CUI) for which a report is returned, whether served from the 24h cache or freshly composed.
- **Actor start** (`actor_start`): **$0.01**, once per run / standby cold boot. In warm MCP standby use, successive reports do not re-charge the start.
- A CUI that resolves to no company (NOT\_FOUND), an invalid CUI, or an upstream error is **not billed**.

| Scenario | Calculation | Total |
|---|---|---|
| One-off check of a single counterparty | $0.01 + 1 × $0.20 | **$0.21** |
| Screen 50 counterparties (one dataset run) | $0.01 + 50 × $0.20 | **$10.01** |
| 200 counterparties (one warm MCP standby session) | $0.01 + 200 × $0.20 | **$40.01** |

A **dataset/task run is capped at 100 CUIs** (one $0.01 start). For higher volumes: either multiple dataset runs (one $0.01 each), or a single warm MCP standby session (one start, many reports). Platform/compute costs are absorbed in the event price, never billed separately. **The 24h per-CUI cache makes a re-call fast, but not free:** every returned report bills identically, cache or fresh (the "checked" evidence is the deliverable).

> ⏱️ **The first call on a cold company is slower**, it triggers a live litigation fetch (SOAP) + a CUI → legal-name resolve + a daily-quota draw. Subsequent calls (within 24h) are served from cache.

#### Known limitations

Being honest up front:

- **No score / rating / verdict**: factual aggregation. You (or the agent) draw the conclusion. (A product choice **and** a GDPR guardrail, see "Why no score".)
- **Romanian companies only, by CUI only**: no name search (re-identification guardrail), no non-RO jurisdictions.
- **No ONRC** (administrators, share capital, beneficial owners), **no financial statements**, **no PEP / adverse media**: declared out of scope, not silently absent.
- **Sanctions at the legal-entity level**, a name match for verification: never a determination.
- **Litigation capped at 1000 cases** per company (the source ceiling); `truncated:true` flags the limit.
- **Heterogeneous freshness**: each signal carries its own `as_of` / `is_stale`; the bundle's `generated_at` is not a single freshness. `max_acceptable_lag_minutes` can tighten (never loosen) the windows.

#### Data source and legal

This Actor scrapes no source directly, it composes the already-ingested substrates of the four sibling Actors:

- **ANAF** (identity/fiscal + the published arrears list): public via the ANAF service.
- **[portal.just.ro](https://portal.just.ro)**: the courts' public service (queries via the SOAP host `portalquery.just.ro`); case metadata is public by statute; private-individual parties are **pseudonymized by design** (orchestrator-side).
- **Sanctions**: **EU FSF** (*Contains EU Financial Sanctions Files data © European Union, reused under Commission Decision 2011/833/EU; modified.*), **OFAC** (a US Government work, public domain), **UN SC** (UN material), **UK** (UK Sanctions List, FCDO; Crown copyright, reusable under the Open Government Licence v3.0), **SECO** (the Swiss consolidated list, State Secretariat for Economic Affairs; official public data). Only the official source list (the EU Official Journal, the UK Sanctions List, OFAC, the UN, or SECO) is authentic, verify any match against the official list.
- **SEAP / SICAP**: public procurement, public data.

#### Privacy & personal data

apnoda-daas is the data controller; Apify, Cloudflare, and Hetzner are Article 28 processors. The controls are architectural, not per-source improvisation:

- **CUI-only input**: no name search (the GDPR re-identification guardrail). The legal name is resolved internally.
- **No own DPIA and no new personal data**: the bundle composes already-minimized data behind existing DPIAs (portal.just.ro; sanctions). The written "why no new DPIA" rationale is recorded in the ROPA (aggregation + Art. 10 data is itself a trigger to reason about, not assume). **Contingency:** the moment a score is added, the Art. 35 trigger fires and a DPIA becomes mandatory.
- **The served legal name** includes the registered name of a PFA / sole trader (a natural person): shown as **public-register data**; the bundle does **not** serve the address.
- **Litigation private-individual parties are pseudonymized**; legal entities, PFA/ÎI/IF, and public institutions pass through under their names.
- **Sanctions**: surfaced as "a possible match to verify", never a determination; a snapshot replaced wholesale on each refresh.
- **Data Subject Requests (DSR):** write to `privacy@apnoda.com`: answered within 30 days (Art. 12(3) GDPR).
- **Public privacy notice:** [apnoda.com/privacy](https://apnoda.com/privacy).

#### Reliability

- **`/compute`-mediated, cache-first**; this Actor reads no Postgres and holds no source secret: a thin proxy over the orchestrator.
- **Soft per-signal degrade:** an unavailable signal (sanctions not loaded, litigation quota exhausted) is marked honestly **in the 200 response** (`UNAVAILABLE` / `available:false` + `quota_exceeded:true`): it does **not** collapse the report and is **not** a tool error.
- Tool-level error codes: `COMPUTE_UNREACHABLE` (transient outage, retry in ~30s); `COMPUTE_UNAVAILABLE` (the orchestrator's data store is temporarily unreachable, retry, report if it persists); `COMPUTE_BAD_REQUEST` (integration error, **permanent**, report it, retrying won't help); `INVALID_INPUT` / `NOT_FOUND` (invalid CUI / no such entity in ANAF, **not billed**); `IDENTITY_UNVERIFIED` (the identity source could not be reached, so existence was NOT verified, distinct from `NOT_FOUND`, retry, **not billed**).
- **The infrastructure is permanent**: regular encrypted backups in Cloudflare R2; periodic DR drill. Never "delete-and-rebuild".

#### Platform-usage transparency

The MCP path runs in Apify standby mode.

- **Standby memory:** 1024 MB (peak RSS measured 2026-06-20: **66 MB**; a thin `/compute` proxy, so 1024 MB leaves large headroom).
- **Warm latency profile (measured against the production standby):**
  - cache-hit call (`due_diligence`, warm CUI): **~265 ms**
  - fresh call (cold CUI, live litigation SOAP): **~4–5 s** (then cached 24h)
  - cold-spawn (first call after idle): **~5–7 s**
- **CU economics:** at 1024 MB the warm standby draws ~1 CU/hour; the per-report compute is dominated by the post-call idle tail, not the ~265 ms call itself. Platform/compute costs are absorbed in the per-event price, no hidden charges.

#### Support

- **Issues or questions:** use the Apify Store contact form on this Actor's page.
- **Other Actors:** browse the [apnoda profile](https://apify.com/apnoda): the bundle pairs naturally with the four sibling Actors (ANAF, portal.just.ro, sanctions, SEAP), each also callable standalone.

#### FAQ

**Why is there no risk score?**
Because a 0–100 score on a named company is profiling that crosses the DPIA threshold (Art. 35) + defamation exposure (we are the controller). We deliver the facts, with every caveat; you draw the conclusion.

**Why CUI-only, no name search?**
The GDPR re-identification guardrail: name input would turn the service into a people-search engine. The CUI identifies a legal entity; the name is resolved internally.

**Does a sanctions `MATCH` mean the company is sanctioned?**
No, a high name-similarity to an official entry, to verify manually. Check `matches[]` against the official source before acting.

**Does `arrears_on_published_list: null` mean "no arrears"?**
No, it means the published list is not loaded at that moment. Only `false` (list loaded + company absent) means "not on the list".

**What is `years_active`?**
A calendar span (last year − first year + 1), not continuously-active years, a company with awards only in 2018 and 2024 reads `years_active = 7`.

**Is the data real-time?**
It reflects our 24h per-CUI cache, recomposed on demand. Each signal carries its own `as_of` / `is_stale`; `max_acceptable_lag_minutes` requests a refresh.

**Can I screen a natural person / a director?**
No, v1 works at the legal-entity level, by CUI. ONRC (administrators, beneficial owners) is reserved as a future premium tier, not in v1.

**How do I control spend?**
Pay-per-event, per report returned, no subscription. Set per-run and monthly spend limits in Apify Console. NOT\_FOUND / invalid CUIs are not billed.

***

*apnoda · privacy@apnoda.com · Version 1.1 · July 2026*

# Actor input Schema

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

Romanian company tax codes (CUI) to run due-diligence on. A valid CUI is bare digits or an RO prefix: "14399840", "RO14399840", or "RO 14399840", all normalized to bare digits. Each valid CUI resolves to one consolidated report record. CUI-only; there is NO free-text company-name input. An entry that is not a valid Romanian CUI (e.g. a foreign VAT id) is skipped per-item and listed in the run's OUTPUT, not run-fatal. Max 100 per run; the first report on a cold company is slower (a live litigation fetch), then cached for 24h.

## `max_acceptable_lag_minutes` (type: `integer`):

Optional freshness ceiling. Bypasses a too-old 24h cache row (recomposed instead of served) and tightens every signal's staleness window so is\_stale honors the ceiling. Omit to accept the default cache freshness. This is an annotation across the six heterogeneous-cadence signals, never a hard fail.

## Actor input object example

```json
{
  "cuis": [
    "14399840"
  ]
}
```

# Actor output Schema

## `reports` (type: `string`):

All due-diligence report records returned by this run. JSON / CSV / XLSX export is available from the Apify dataset API at the URL below.

# 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": [
        "14399840"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("apnoda/romania-dd-bundle").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": ["14399840"] }

# Run the Actor and wait for it to finish
run = client.actor("apnoda/romania-dd-bundle").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "14399840"
  ]
}' |
apify call apnoda/romania-dd-bundle --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=apnoda/romania-dd-bundle",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Romania Company Due Diligence (CUI)",
        "description": "One-call factual due diligence on a Romanian company by CUI: identity & fiscal standing (ANAF), published tax arrears, EU/OFAC/UN/UK/SECO sanctions screening, litigation & insolvency (portal.just.ro), and procurement history (SEAP). No score, rating, or recommendation. CUI-keyed; no name search.",
        "version": "0.1",
        "x-build-id": "dgU0Wl0gGPLpjxfPt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/apnoda~romania-dd-bundle/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-apnoda-romania-dd-bundle",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/apnoda~romania-dd-bundle/runs": {
            "post": {
                "operationId": "runs-sync-apnoda-romania-dd-bundle",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/apnoda~romania-dd-bundle/run-sync": {
            "post": {
                "operationId": "run-sync-apnoda-romania-dd-bundle",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "cuis": {
                        "title": "Company tax codes (CUI)",
                        "maxItems": 100,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Romanian company tax codes (CUI) to run due-diligence on. A valid CUI is bare digits or an RO prefix: \"14399840\", \"RO14399840\", or \"RO 14399840\", all normalized to bare digits. Each valid CUI resolves to one consolidated report record. CUI-only; there is NO free-text company-name input. An entry that is not a valid Romanian CUI (e.g. a foreign VAT id) is skipped per-item and listed in the run's OUTPUT, not run-fatal. Max 100 per run; the first report on a cold company is slower (a live litigation fetch), then cached for 24h.",
                        "items": {
                            "type": "string",
                            "pattern": "^(?:[A-Za-z]+\\s*)?[0-9]{2,10}$"
                        },
                        "default": []
                    },
                    "max_acceptable_lag_minutes": {
                        "title": "Max acceptable cache lag (minutes)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional freshness ceiling. Bypasses a too-old 24h cache row (recomposed instead of served) and tightens every signal's staleness window so is_stale honors the ceiling. Omit to accept the default cache freshness. This is an annotation across the six heterogeneous-cadence signals, never a hard fail."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
