# Romanian Courts Case Lookup (portal.just.ro) (`apnoda/portal-just`) Actor Romanian court case lookup from portal.just.ro for due diligence: search a company's litigation by CUI, look up a case by file number, or pull a court's cause-list for a date. Penal-matter flag, procedural stage, MCP-native, pay-per-event. Private individuals pseudonymized by design. - **URL**: https://apify.com/apnoda/portal-just.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 $60.00 / 1,000 case returned (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 ## Căutare Dosare Instanțe România (portal.just.ro) 🇷🇴 [Română](#română) · 🇬🇧 [English](#english) --- ### Română **Dosare din instanțele românești (portal.just.ro), livrate ca date structurate pentru due-diligence și agenți AI.** Caută litigiile unei firme după CUI, caută un dosar după număr, sau extrage lista de ședințe a unei instanțe pe o zi. Compatibil MCP, plată pe rezultat, fără abonament și fără cont. Numele persoanelor fizice sunt pseudonimizate prin proiectare. > 🤖 **Pregătit pentru plăți agentice:** x402 (automat pentru orice Actor cu preț pay-per-event). > > 🎬 *Demo de 20s:* #### Ce face acest Actor Caută dosare în instanțele românești prin serviciul public **portal.just.ro** ([portalquery.just.ro](http://portalquery.just.ro)) și livrează înregistrări JSON normalizate: instanța, tipul materiei (`categorieCaz`) + un indicator de **materie penală**, stadiul procesual, părțile (pseudonimizate acolo unde sunt persoane fizice), ședințele și căile de atac. Pentru fiecare dosar primești: - **Materia + indicatorul penal**: tipul cauzei (`categorieCaz`) și `is_penal` (adevărat când cauza este una **penală**, în sensul Codului penal). Un **fapt juridic**, formulat neutru, niciodată „fraudă"/„suspect". - **Stadiul procesual**: `Fond` / `Apel` / `Recurs` etc., cu eticheta lizibilă. - **Părțile, pseudonimizate prin proiectare**: persoanele juridice, PFA/ÎI/IF și instituțiile publice trec nealterate; persoanele fizice sunt înlocuite cu un token stabil în cadrul dosarului (ex.: `Parte-A`), astfel încât relațiile de rol se păstrează fără a expune numele. - **Ședințe + căi de atac**: complet, dată, oră, soluție/soluție sumară, tip de cale de atac. Listele de ședințe (`CautareSedinte`) **nu conțin nume de părți**. - **Proveniența join-ului DD**: la căutarea după CUI, fiecare dosar poartă `matched_company_cui` / `matched_company_denumire` (CUI-ul căutat + numele legal rezolvat), pentru încrucișarea cu ANAF (build #2) și ONRC (build #6). Datele de bază sunt publice și gratuite pe portal.just.ro, diferența acestui Actor este **căutare după CUI + indicator penal + nativ-MCP + pseudonimizat prin proiectare + apelabil de un agent**, într-un singur tur. #### De ce să folosești acest Actor Trei profiluri: **Pentru dezvoltatori de agenți AI:** Compatibil MCP din prima zi. Te conectezi via `mcp.apify.com?tools=apnoda/portal-just` și agentul tău are **4 unelte**: `lookup_case`, `search_cases`, `list_hearings`, `list_courts`. Fără abonamente, fără chei API, fără infrastructură. **Pentru dezvoltatori care construiesc instrumente de due-diligence:** Serviciul portal.just.ro este SOAP, caută după nume și plafonează la 1000 de rezultate per interogare. Acest Actor îl abstractizează, **caută litigiile după CUI** (rezolvând intern CUI → denumire legală), derivă indicatorul `is_penal`, atașează proveniența join-ului și pseudonimizează părțile persoane fizice. Output stabil și tipat. **Pentru conformitate, KYC/AML și jurnaliști:** Verifică expunerea în instanță a unei liste de contrapărți după CUI într-un singur apel. Export în CSV. Plătești cenți pe dosar returnat. Fără cont la un SaaS de informații juridice. #### Încearcă acum 1. **Lipește numere de dosar** în câmpul `caseNumbers` (ex.: `["6597/2/2021"]`) **și/sau CUI-uri de firme** în `companyCuis` (ex.: `["14399840"]`) și pornește Actorul. 2. **Exportă ca CSV** și deschide în Excel / Google Sheets. 3. **SAU** conectează via MCP și întreabă Claude în limbaj natural (vezi secțiunea următoare). Plătești doar pe dosar returnat, un număr de dosar inexistent sau un CUI fără litigii (NOT_FOUND / rezultat gol) nu se taxează. Creditul Apify de $5 la înscriere acoperă circa 80 de dosare returnate (la $0.06 fiecare). #### Comparație rapidă | Capabilitate | Acest Actor | Portal public portal.just.ro (gratuit) | Platforme plătite de informații juridice | |---|---|---|---| | Căutare litigii după CUI (un apel) | ✅ CUI → denumire | ❌ doar după nume, manual | parțial (în UI) | | În masă (multe firme/dosare, o rulare) | ✅ până la 100 | ❌ unul câte unul | parțial | | Acces MCP / agenți AI | ✅ | ❌ | ❌ | | Indicator de materie penală (`is_penal`) | ✅ | ❌ (materie brută) | ✅ în UI | | Părți pseudonimizate prin proiectare (GDPR) | ✅ | ❌ (nume complete afișate) | variabil | | API programatic / export CSV | ✅ | ❌ | limitat | | Plată la utilizare, fără cont | ✅ | ✅ (gratuit, manual) | ❌ abonament | | Model de preț | pay-per-event | gratuit (manual, 1 la 1) | abonament | Nișa acestui Actor: **stratul de litigii pentru due-diligence, apelabil după CUI, de către agenți, pseudonimizat prin proiectare, peste datele publice ale instanțelor.** Datele de bază există gratuit pe portal.just.ro (căutabile după nume). Diferența: livrăm join-ul după CUI, în masă, prin API sau MCP, pseudonimizat, plătit doar la utilizare. ⚠️ **Acest Actor NU oferă direct:** - Căutare după numele unei persoane / al unei părți (gardă de re-identificare GDPR, căutare după CUI + după număr de dosar). Persoanele fizice apar pseudonimizate și în output. - Numele reale ale persoanelor fizice (sunt tokenizate prin proiectare; firmele, PFA/ÎI/IF și instituțiile apar cu numele lor). - Un **scor** de risc litigios, pachetul de due-diligence (build #6) îl compune; acest Actor emite câmpurile de intrare + `is_penal`. - Date ONRC (administratori, capital, beneficiari reali), situații financiare sau o interfață vizuală pentru echipă. #### Utilizare MCP Conectează Claude Desktop (sau orice client MCP) adăugând în configurație: ```json { "mcpServers": { "romanian-courts": { "url": "https://mcp.apify.com?tools=apnoda/portal-just" } } } ```` Apoi întreabă Claude lucruri precum: - *"Are firma cu CUI 14399840 dosare pe rol, și sunt vreunele cauze penale?"* - *"Caută dosarul 6597/2/2021 și rezumă stadiul procesual și părțile."* - *"Listează ședințele de azi de la Curtea de Apel București."* Claude alege unealta potrivită, o apelează și răspunde. Plătești pe dosar returnat / listă de ședințe, nu pe interogare. ##### Unelte MCP disponibile (4) | Unealtă | Ce face | |---|---| | **`lookup_case`** | Un dosar după numărul de înregistrare (ex.: „6597/2/2021"). Returnează instanța, materia (`categorieCaz`) + indicatorul penal, stadiul procesual, părțile (pseudonimizate unde sunt persoane fizice), ședințele și căile de atac. | | **`search_cases`** | Litigiile unei firme după CUI, punctul de pârghie pentru DD. Orchestratorul rezolvă CUI → denumire legală și caută dosarele după acea denumire (fără input de tip nume liber). Filtre opționale după instanță + perioadă, plus `max_results` (implicit 50, maxim 1000) ca plafon de cost predictibil per apel. Livrează dosarele returnate; `result_count` dă numărul total găsit, iar `truncated` semnalează că există mai multe. | | **`list_hearings`** | Lista de ședințe (`ședințe`) a unei instanțe, pentru o anumită zi. Complete, ore și dosarele programate, fără nume de părți. | | **`list_courts`** | Directorul celor 246 de instanțe interogabile, fiecare cu `token` + tip (Judecătorie, Tribunal, Curte de Apel etc.). **Gratuit** și static: niciun apel live, netarifat. Filtrare opțională după tip. Îl folosești ca să descoperi valoarea exactă `court` cerută de `search_cases` și `list_hearings`. | #### Utilizare Apify (non-MCP) Rulaj standard. Configurezi input-ul, pornești, colectezi rezultatele din dataset. Rularea în lot este axată pe dosare (o înregistrare per dosar rezolvat); `list_hearings` și `list_courts` rămân unelte pe suprafața MCP. ```json { "companyCuis": ["14399840", "RO 38150891"], "caseNumbers": ["6597/2/2021"], "court": "Curtea de Apel BUCUREŞTI", "periodStart": "2020-01-01", "maxAcceptableLagMinutes": 1440 } ``` Output-ul ajunge într-un dataset Apify standard. Exportă ca JSON, CSV sau XLSX. Trei vederi pre-definite: `overview` (JSON implicit), `csv_export` (plat, toate câmpurile scalare, plus scalarii derivați din ședințe: `next_hearing_date`, `latest_hearing_date`, `latest_solution`, ca să răspunzi la întrebările de bază fără să parsezi array-ul de ședințe) și `mcp_compact` (câmpurile esențiale pentru decizia „merge / nu merge"). #### Ce primești Fiecare înregistrare este un dosar (exemplu ilustrativ, părți generice): ```json { "case_number": "6597/2/2021", "registered_at": "2021-03-15", "court": "Curtea de Apel BUCUREŞTI", "department": "Secția a VIII-a Contencios Administrativ și Fiscal", "category": "Litigii cu profesioniștii", "is_penal": false, "stage": "Fond", "subject": "pretenții", "last_modified_at": "2024-11-18", "party_count": 3, "hearing_count": 1, "appeal_count": 1, "next_hearing_date": null, "latest_hearing_date": "2024-10-18", "latest_solution": "Amânat", "parties": [ { "name": "EXEMPLU CONSTRUCT S.R.L.", "role": "Reclamant", "is_pseudonymized": false }, { "name": "PRIMĂRIA EXEMPLU", "role": "Pârât", "is_pseudonymized": false }, { "name": "Parte-A", "role": "Intervenient", "is_pseudonymized": true } ], "hearings": [ { "panel": "C5", "date": "2024-10-18T00:00:00", "time": "09:00", "solution": "Amânat", "solution_summary": null, "ruling_date": null, "document_type": "Încheiere", "document_number": null, "document_date": "2024-10-18T00:00:00" } ], "appeals": [ { "appeal_type": "Apel", "declaring_party": "EXEMPLU CONSTRUCT S.R.L.", "declaring_party_is_pseudonymized": false, "declared_date": "2024-11-15" } ], "matched_company_cui": "14399840", "matched_company_denumire": "EXEMPLU CONSTRUCT S.R.L.", "search_truncated": false, "as_of": "2026-06-10T20:04:32.000Z", "lag_minutes": 12, "is_stale": false, "source": "cache" } ``` Adnotarea de prospețime (`as_of` / `lag_minutes` / `is_stale` / `source`) urmărește momentul ultimei extrageri din portal.just.ro, astfel încât agentul tău știe cât de proaspete sunt datele. `is_stale` este întotdeauna `false` prin construcție, un rând de cache expirat este re-extras, nu servit. #### Exemplu real: trierea unui portofoliu de contrapărți Apelezi `search_cases` pentru o listă de CUI-uri de furnizori și citești semnalele: ``` 12 CUI-uri căutate → 47 dosare returnate la 9 firme (3 fără litigii) 9 dosare is_penal: true → cauze penale, semnalează pentru analiză juridică 21 dosare stage: "Apel"/"Recurs" → aflate în căi de atac 47 dosare părți pseudonimizate acolo unde sunt persoane fizice (token-uri, nu nume) ``` Costul întregii trieri: **~$2.83** (47 × $0.06 + $0.01 pornire). Timp de răspuns: câteva secunde. Exact genul de verificare pe care echipele de DD, KYC/AML și jurnaliștii o rulează înainte de a contracta. #### Calculator de costuri **Prețuri:** - Pornire Actor: $0.01 (o dată per rulaj / pornire la rece în standby) - Per dosar returnat (`case_returned`): **$0.06**, evenimentul principal - Per listă de ședințe nevidă (`hearing_list_returned`): $0.04 - Numere de dosar inexistente (NOT\_FOUND), CUI-uri fără litigii și liste de ședințe goale, **niciodată taxate**. Costurile de platformă/calcul sunt absorbite în prețul evenimentului, fără taxe ascunse. | Caz de utilizare | Apel | Rezultate | Cost | |---|---|---|---| | Cauți un singur dosar | `lookup_case` | 1 dosar | ~$0.06 | | Triezi litigiile unei firme | `search_cases` | ~8 dosare | ~$0.48 | | Triezi o firmă cu multe litigii | `search_cases` (implicit) | 50 dosare (plafonat) | ~$3.00 | | Triezi un portofoliu de 50 firme | `search_cases` ×50 | ~300 dosare | ~$18.00 | | Extragi lista de ședințe a unei instanțe | `list_hearings` | 1 listă | ~$0.04 | | Descoperi instanțele interogabile | `list_courts` | 246 de instanțe | **$0** (gratuit) | `search_cases` plafonează implicit la 50 de dosare per apel (`max_results`), deci un singur apel nu depășește ~$3.00 chiar pentru o firmă foarte litigioasă; ridici `max_results` (maxim 1000) când vrei tot, iar `result_count` îți arată mereu numărul real de dosare. Fiecare rulare (sau pornire la rece în standby) adaugă, o singură dată, și tariful `actor_start` de $0.01. #### Limitări cunoscute Sincer, de la început: - **Fără căutare după nume / parte.** Input-ul este exclusiv CUI (firme) + număr de dosar: gardă de re-identificare GDPR. - **Părțile persoane fizice sunt pseudonimizate.** Primești token-uri stabile în cadrul dosarului (ex.: `Parte-A`), nu nume. Firmele, PFA/ÎI/IF și instituțiile publice trec cu numele lor. - **Filtrul de instanță folosește lista oficială.** Dă un nume de instanță („Curtea de Apel București", cu sau fără diacritice) sau token-ul portal.just.ro; o instanță nerecunoscută întoarce `INVALID_INPUT` (nu se consumă cotă). Lasă gol pentru a căuta în toate instanțele. - **Câmpurile text liber nu sunt scanate NER.** `obiect` / `soluție` pot conține incidental un nume pe care pseudonimizarea (axată pe câmpul de parte) nu îl prinde: un reziduu acceptat și documentat; câmpurile structurate ale părților **sunt** pseudonimizate. - **50 de dosare livrate implicit per căutare după CUI** (`max_results`, plafon de cost predictibil; îl ridici până la 1000, plafonul sursei). `truncated` semnalează că există mai multe dosare decât cele returnate, iar `result_count` dă numărul total găsit. Rulajul batch (dataset) livrează tot, până la plafonul sursei, și semnalează plafonul sursei prin `search_truncated` (coloana „Search capped"). - **Listele de ședințe nu conțin nume de părți** (`CautareSedinte` returnează complete + dosare). - **Prospețime din cache, la cerere.** Rezultatele provin din cache-ul nostru, re-extras la cerere (cu limită de cotă); fiecare înregistrare poartă adnotarea de prospețime, iar `max_acceptable_lag_minutes` poate strânge (niciodată lărgi) fereastra. Fiecare unealtă MCP facturabilă întoarce și cota de fetch live rămasă (`quota`: {count, cap, remaining}), ca un agent să se poată auto-limita înainte de `QUOTA_EXCEEDED` (se resetează la 00:00 UTC). - **Fără scor de risc, fără ONRC, fără situații financiare.** #### Sursa datelor și aspecte legale - **portal.just.ro** ([portalquery.just.ro](http://portalquery.just.ro)): serviciul public al instanțelor din România. Metadatele dosarelor sunt publice prin statut. Acest Actor împachetează datele publice ale instanțelor pentru consum automat și agenți AI, pseudonimizând părțile persoane fizice. #### Confidențialitate & date personale apnoda-daas este operatorul de date; Apify, Cloudflare și Hetzner sunt persoane împuternicite conform Art. 28. Controalele de confidențialitate sunt arhitecturale, nu improvizate per sursă: - **Persoanele fizice sunt pseudonimizate** (token stabil în cadrul dosarului); persoanele juridice, PFA/ÎI/IF și instituțiile publice trec nealterate. - **Doar input CUI**: fără căutare după nume (garda de re-identificare). - **CNP și datele de contact** sunt eliminate. - **`is_penal` / `categorieCaz` sunt fapte juridice**, formulate neutru: niciodată „fraudă"/„suspect"/„ilegal". - **DPIA** pe dosar, **ROPA** menținut (Art. 30), retenție documentată, ștergere per-înregistrare în arhiva R2 (unitatea de ștergere este dosarul, după numărul de dosar). - **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**; fiecare înregistrare poartă prospețime (`as_of` / `lag_minutes` / `is_stale` / `source` ∈ cache / live). - `COMPUTE_UNREACHABLE` (pană tranzitorie) = reîncearcă în ~30s; `QUOTA_EXCEEDED` = plafon zilnic atins, reîncearcă după miezul nopții UTC (căutările din cache nu sunt afectate); `COMPUTE_UNAVAILABLE` (serviciul nu este activat pe orchestrator, problemă de configurare apnoda) și `COMPUTE_BAD_REQUEST` (eroare de integrare) = **permanente, raportează, reîncercarea nu ajută**. - **Backup** la fiecare 6 ore, retenție 7 zile în Cloudflare R2 (criptat AES-256); exercițiu DR bilunar. Infrastructura este permanentă, niciodată „șterge-și-reconstruiește". #### Transparență privind utilizarea platformei Calea MCP rulează în modul standby Apify. - **Memorie standby:** 1024 MB (RSS de vârf măsurat ~64 MB, marjă confortabilă). - **Profil de latență (warm), p50 / p95** (măsurat 2026-07-14 împotriva URL-ului standby de producție, N=30 per categorie, cache warm): - `lookup_case` (un singur dosar): 261 / 388 ms - `search_cases` (căutare după CUI, mai multe dosare): 406 / 582 ms - `list_hearings` (listă de ședințe): 276 / 784 ms - `list_courts` (gratuit, director static): 145 / 156 ms - pornire la rece (primul apel după inactivitate prelungită): ~5850 ms (provizionare container Apify + pornire Node; afectează doar primul apel) Un cache miss declanșează o preluare live de la portal.just.ro, care adaugă runda SOAP a sursei și este mai lentă și variabilă; acest profil este calea cu cache warm. - **Calcul de platformă:** absorbit în prețul pe eveniment, fără taxe ascunse. Facturarea standby este bazată pe timp: containerul rămâne activ ~5 minute între apeluri (coada de inactivitate), deci costul dominant este timpul de standby în timp real, nu apelul activ de sub o secundă. #### 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) pentru instrumente de date birocratice România/CEE. #### Întrebări frecvente **Î: Datele sunt în timp real?** R: Reflectă cache-ul nostru, re-extras la cerere din portal.just.ro (cu limită de cotă). Fiecare înregistrare poartă adnotarea de prospețime (`as_of` / `lag_minutes` / `is_stale`), iar agentul poate cere o reîmprospătare cu `max_acceptable_lag_minutes`. **Î: De ce nu pot căuta după numele unei persoane?** R: Gardă de re-identificare GDPR, căutarea de firme este exclusiv după CUI, plus căutarea după numărul de dosar. Părțile persoane fizice apar pseudonimizate și în output. **Î: Ce este indicatorul `is_penal`?** R: Un **fapt juridic**, că materia dosarului este una penală (în sensul Codului penal). NU este o acuzație la adresa vreunei părți; este surfacelat pentru ponderarea în due-diligence. **Î: Pot obține numele reale ale persoanelor fizice?** R: Nu, sunt pseudonimizate prin proiectare. Firmele, PFA/ÎI/IF și instituțiile publice apar cu numele lor reale. **Î: Pot folosi datele într-un produs comercial?** R: Da, dosarele instanțelor sunt publice. Nu poți revinde datele brute ca un portal.just.ro concurent. **Î: Cum controlez cheltuielile?** R: Plată pe eveniment, pe dosar returnat / listă de ședințe, fără abonament. Setezi limite per-rulaj și lunare în Apify Console. Dosarele NOT\_FOUND și rezultatele goale nu se taxează. **Î: Care e diferența față de portalul public gratuit portal.just.ro?** R: Căutare a litigiilor după CUI (nu doar după nume/număr), în masă, nativ-MCP, pseudonimizat prin proiectare, cu export API/CSV, într-un singur apel, apelabil de un agent. *Versiunea 1.0 · Actualizat iunie 2026* *** ### English **Romanian court case-files (portal.just.ro) as structured data for due diligence and AI agents.** Search a company's litigation by CUI, look up a case by file number, or pull a court's cause-list for a date. MCP-native, pay-per-result, no subscription and no account. Private individuals' names are pseudonymized by design. > 🤖 **Agentic-payments ready:** x402 (automatic for any pay-per-event Actor). > > 🎬 *20-second demo:* #### What this Actor does Looks up Romanian court cases through the public **portal.just.ro** service ([portalquery.just.ro](http://portalquery.just.ro)) and returns normalized JSON records: the court, the matter type (`categorieCaz`) + a **penal-matter** flag, the procedural stage, the parties (pseudonymized where they are private individuals), the hearings, and the appeals. For each case you get: - **Matter type + penal flag**: the case category (`categorieCaz`) and `is_penal` (true when the matter is a **penal** one, i.e. tried under the Penal Code). A **legal fact**, phrased neutrally, never "fraud"/"suspect". - **Procedural stage**: `Fond` / `Apel` / `Recurs` (first instance / appeal / second appeal) etc., with the readable label. - **Parties, pseudonymized by design**: legal entities, sole traders (PFA/ÎI/IF), and public institutions pass through unaltered; private individuals are replaced with a within-case-stable token (e.g. `Parte-A`), so role relationships survive without exposing names. - **Hearings + appeals**: panel, date, time, solution / summary, appeal type. Cause-lists (`CautareSedinte`) carry **no party names**. - **DD-join provenance**: on a CUI search, every case carries `matched_company_cui` / `matched_company_denumire` (the searched CUI + its resolved legal name), for cross-referencing with ANAF (build #2) and ONRC (build #6). The underlying data is public and free on portal.just.ro, this Actor's difference is **CUI-keyed search + penal flag + MCP-native + pseudonymized by design + agent-callable**, in one round-trip. #### Why use this Actor Three buyer profiles: **For AI-agent developers:** MCP-native from day one. Connect via `mcp.apify.com?tools=apnoda/portal-just` and your agent has **4 tools**: `lookup_case`, `search_cases`, `list_hearings`, `list_courts`. No subscriptions, no API keys, no infrastructure. **For developers building due-diligence tools:** portal.just.ro is a SOAP service, searches by name, and caps at 1000 results per query. This Actor abstracts it, **searches litigation by CUI** (resolving CUI → legal name internally), derives the `is_penal` flag, attaches join provenance, and pseudonymizes private-individual parties. Output is stable and typed. **For compliance, KYC/AML, and journalists:** Vet a list of counterparties' court exposure by CUI in one call. Export to CSV. Pay cents per case returned. No account with a legal-intelligence SaaS required. #### Try it now 1. **Paste case file numbers** into the `caseNumbers` field (e.g. `["6597/2/2021"]`) **and/or company CUIs** into `companyCuis` (e.g. `["14399840"]`) and start the Actor. 2. **Export as CSV** and open in Excel / Google Sheets. 3. **OR** connect via MCP and ask Claude in natural language (see the next section). You pay only per case returned, a case number with no record, or a company CUI with no litigation (NOT\_FOUND / empty result), is not billed. Apify's $5 signup credit covers around 80 returned cases (at $0.06 each). #### Quick comparison | Capability | This Actor | portal.just.ro public portal (free) | Paid legal-intelligence platforms | |---|---|---|---| | Litigation search by CUI (one call) | ✅ CUI → legal name | ❌ name-only, manual | partial (in UI) | | Bulk (many companies/cases, one run) | ✅ up to 100 | ❌ one at a time | partial | | MCP / AI-agent access | ✅ | ❌ | ❌ | | Penal-matter flag (`is_penal`) | ✅ | ❌ (raw matter type) | ✅ in UI | | Parties pseudonymized by design (GDPR) | ✅ | ❌ (full names shown) | varies | | Programmatic API / CSV export | ✅ | ❌ | limited | | Pay-per-use, no account | ✅ | ✅ (free, manual) | ❌ subscription | | Pricing model | pay-per-event | free (manual, 1-at-a-time) | subscription | This Actor's niche: **the litigation layer for due diligence, CUI-keyed, agent-callable, pseudonymized by design, over the courts' public data.** The base data exists for free on portal.just.ro (name-searchable). The difference: we deliver the CUI-join, in bulk, via API or MCP, pseudonymized, pay-per-use only. ⚠️ **This Actor does NOT provide directly:** - Name-based / party search (GDPR re-identification guardrail, search is by CUI + by case number). Private individuals appear pseudonymized in the output too. - The real names of private individuals (they are tokenized by design; companies, PFA/ÎI/IF, and institutions appear under their names). - A litigation-risk **score**, the due-diligence bundle (build #6) composes that; this Actor emits the input fields + `is_penal`. - ONRC data (administrators, share capital, beneficial owners), financial statements, or a visual team UI. #### MCP-first usage Connect Claude Desktop (or any MCP client) by adding this to your config: ```json { "mcpServers": { "romanian-courts": { "url": "https://mcp.apify.com?tools=apnoda/portal-just" } } } ``` Now ask Claude things like: - *"Does the company with CUI 14399840 have any open court cases, and are any of them penal matters?"* - *"Look up case 6597/2/2021 and summarize its procedural stage and parties."* - *"List today's cause-list for Curtea de Apel București."* Claude picks the right tool, calls it, and answers. You pay per case returned / per cause-list, not per query. ##### Available MCP tools (4) | Tool | What it does | |---|---| | **`lookup_case`** | One case by file number (e.g. "6597/2/2021"). Returns the court, matter type (`categorieCaz`) + penal flag, procedural stage, parties (pseudonymized where private individuals), hearings, and appeals. | | **`search_cases`** | A company's litigation by CUI, the DD leverage point. The orchestrator resolves CUI → legal name and searches cases by that name (no free-text name input). Optional court + period filters, plus `max_results` (default 50, max 1000) as a predictable per-call spend cap. Delivers the returned cases; `result_count` gives the full number found and `truncated` flags that more exist. | | **`list_hearings`** | A court's cause-list (`ședințe`) for a given date. Panels, times, and the scheduled cases, no party names. | | **`list_courts`** | The directory of all 246 queryable courts, each as `token` + tier (Judecătorie, Tribunal, Curte de Apel, etc.). **Free** and static: no live call, never billed. Optional `type` filter. Use it to discover the exact `court` value that `search_cases` and `list_hearings` expect. | #### Apify usage (non-MCP) Standard Actor run. Configure inputs, start, collect dataset results. The batch run is case-focused (one record per resolved case); `list_hearings` and `list_courts` stay MCP-surface tools. ```json { "companyCuis": ["14399840", "RO 38150891"], "caseNumbers": ["6597/2/2021"], "court": "Curtea de Apel BUCUREŞTI", "periodStart": "2020-01-01", "maxAcceptableLagMinutes": 1440 } ``` Output lands in a standard Apify dataset. Export as JSON, CSV, or XLSX. Three pre-built views: `overview` (default JSON), `csv_export` (flat, all scalar fields, plus the derived hearing scalars `next_hearing_date`, `latest_hearing_date`, and `latest_solution` so you can answer "is it moving? / next hearing? / last solution?" without parsing the hearings array), and `mcp_compact` (the go/no-go due-diligence fields). #### What you get Every record is one case (illustrative example, generic parties): ```json { "case_number": "6597/2/2021", "registered_at": "2021-03-15", "court": "Curtea de Apel BUCUREŞTI", "department": "Secția a VIII-a Contencios Administrativ și Fiscal", "category": "Litigii cu profesioniștii", "is_penal": false, "stage": "Fond", "subject": "pretenții", "last_modified_at": "2024-11-18", "party_count": 3, "hearing_count": 1, "appeal_count": 1, "next_hearing_date": null, "latest_hearing_date": "2024-10-18", "latest_solution": "Amânat", "parties": [ { "name": "EXEMPLU CONSTRUCT S.R.L.", "role": "Reclamant", "is_pseudonymized": false }, { "name": "PRIMĂRIA EXEMPLU", "role": "Pârât", "is_pseudonymized": false }, { "name": "Parte-A", "role": "Intervenient", "is_pseudonymized": true } ], "hearings": [ { "panel": "C5", "date": "2024-10-18T00:00:00", "time": "09:00", "solution": "Amânat", "solution_summary": null, "ruling_date": null, "document_type": "Încheiere", "document_number": null, "document_date": "2024-10-18T00:00:00" } ], "appeals": [ { "appeal_type": "Apel", "declaring_party": "EXEMPLU CONSTRUCT S.R.L.", "declaring_party_is_pseudonymized": false, "declared_date": "2024-11-15" } ], "matched_company_cui": "14399840", "matched_company_denumire": "EXEMPLU CONSTRUCT S.R.L.", "search_truncated": false, "as_of": "2026-06-10T20:04:32.000Z", "lag_minutes": 12, "is_stale": false, "source": "cache" } ``` The freshness annotation (`as_of` / `lag_minutes` / `is_stale` / `source`) tracks when the result was last fetched from portal.just.ro, so your agent knows how fresh the data is. `is_stale` is always `false` by construction, a stale cache row is refetched, not served. #### Real example: screening a counterparty portfolio Call `search_cases` for a list of supplier CUIs and read the signals: ``` 12 CUIs searched → 47 cases returned across 9 companies (3 had none) 9 cases is_penal: true → penal matters, flag for legal review 21 cases stage: "Apel"/"Recurs" → under appeal 47 cases parties pseudonymized where private individuals (tokens, not names) ``` Cost of the whole screen: **~$2.83** (47 × $0.06 + $0.01 start). Time to return: a few seconds. Exactly the kind of check DD, KYC/AML, and investigative teams run before contracting. #### Cost calculator **Pricing:** - Actor start: $0.01 (once per run / standby cold boot) - Per case returned (`case_returned`): **$0.06**, the primary event - Per non-empty cause-list (`hearing_list_returned`): $0.04 - Case numbers with no record (NOT\_FOUND), CUIs with no litigation, and empty cause-lists are **never billed**. Platform/compute costs are absorbed in the event price, no hidden charges. | Use case | Call | Records | Cost | |---|---|---|---| | Look up a single case | `lookup_case` | 1 case | ~$0.06 | | Screen one company's litigation | `search_cases` | ~8 cases | ~$0.48 | | Screen a heavily-litigated company | `search_cases` (default) | 50 cases (capped) | ~$3.00 | | Screen a 50-company portfolio | `search_cases` ×50 | ~300 cases | ~$18.00 | | Pull a court's cause-list | `list_hearings` | 1 list | ~$0.04 | | Discover the queryable courts | `list_courts` | 246 courts | **$0** (free) | `search_cases` caps at 50 cases per call by default (`max_results`), so one call never exceeds ~$3.00 even for a heavily-litigated company; raise `max_results` (max 1000) when you want them all, and `result_count` always shows the true case count. Each run (or standby cold boot) also adds the one-time `actor_start` fee of $0.01. #### Known limitations Being honest up front: - **No name-based / party search.** Input is CUI-only (companies) + case number: a GDPR re-identification guardrail. - **Private-individual parties are pseudonymized.** You get within-case-stable tokens (e.g. `Parte-A`), not names. Companies, PFA/ÎI/IF, and public institutions pass through under their names. - **The court filter uses the official court list.** Pass a court name ("Curtea de Apel București", diacritics optional) or its portal.just.ro token; an unrecognized court returns `INVALID_INPUT` (no quota drawn). Leave it blank to search all courts. - **Free-text fields are not NER-scrubbed.** `obiect` / `soluție` may incidentally contain a name the (party-field-focused) pseudonymizer doesn't catch: an accepted, documented residual; the structured party fields **are** pseudonymized. - **50 cases delivered per CUI search by default** (`max_results`, a predictable spend cap; raise it up to 1000, the source ceiling). `truncated` flags that more cases exist than were returned, and `result_count` gives the full number found. The batch/dataset run delivers everything up to the source ceiling and signals it via `search_truncated` (the "Search capped" column). - **Cause-lists carry no party names** (`CautareSedinte` returns panels + scheduled cases). - **Cached freshness, on demand.** Results come from our cache, refetched on demand (quota-bounded); every record carries the freshness annotation, and `max_acceptable_lag_minutes` can tighten (never loosen) the window. Each billable MCP tool also returns the remaining live-fetch quota (`quota`: {count, cap, remaining}) so an agent can self-throttle before `QUOTA_EXCEEDED` (which resets at 00:00 UTC). - **No risk score, no ONRC, no financial statements.** #### Data source and legal - **portal.just.ro** ([portalquery.just.ro](http://portalquery.just.ro)): the Romanian courts' public service. Court case metadata is public by statute. This Actor packages the courts' public data for machine consumption and AI agents, pseudonymizing private-individual parties. #### Privacy & personal data apnoda-daas is the data controller; Apify, Cloudflare, and Hetzner are Article 28 processors. The privacy controls are architectural, not per-source improvisation: - **Private individuals are pseudonymized** (a within-case-stable token); legal entities, PFA/ÎI/IF, and public institutions pass through unaltered. - **CUI-only input**: no name search (the re-identification guardrail). - **CNP and contact fields are stripped.** - **`is_penal` / `categorieCaz` are legal facts**, phrased neutrally: never "fraud"/"suspect"/"illegal". - **DPIA** on file, **ROPA** maintained (Art. 30), documented retention, per-record erasure in the R2 raw archive (the erasure unit is the case, keyed on the case number). - **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**; every record carries freshness (`as_of` / `lag_minutes` / `is_stale` / `source` ∈ cache / live). - `COMPUTE_UNREACHABLE` (transient outage) = retry in ~30s; `QUOTA_EXCEEDED` = daily cap hit, retry after UTC midnight (cached lookups are unaffected); `COMPUTE_UNAVAILABLE` (service not enabled on the orchestrator, an apnoda-side config issue) and `COMPUTE_BAD_REQUEST` (integration error) = **permanent, report it, retrying won't help**. - **Backups** every 6 hours, 7-day retention in Cloudflare R2 (AES-256 encrypted); bi-monthly DR drill. The infrastructure is permanent, never "delete-and-rebuild". #### Platform-usage transparency The MCP path runs in Apify standby mode. - **Standby memory:** 1024 MB (measured peak RSS ~64 MB, comfortable headroom). - **Warm latency profile, p50 / p95** (measured 2026-07-14 against the production standby URL, N=30 per category, warm cache hit): - `lookup_case` (single case): 261 / 388 ms - `search_cases` (multi-case CUI query): 406 / 582 ms - `list_hearings` (cause-list): 276 / 784 ms - `list_courts` (free, static directory): 145 / 156 ms - cold-spawn (first call after extended idle): ~5850 ms (Apify container provisioning + Node start; affects only the first call) A cache miss triggers a live portal.just.ro fetch, which adds the source's SOAP round-trip and is slower and variable; this profile is the warm cache-hit path. - **Platform compute:** absorbed in the per-event price, no hidden charges. Standby billing is time-based: the container stays warm for a ~5 minute idle-tail between calls, so the dominant cost is wall-clock standby time, not the sub-second active call. #### 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) for Romanian/CEE bureaucratic-data tools. #### FAQ **Q: Is the data real-time?** A: It reflects our cache, refetched on demand from portal.just.ro (quota-bounded). Every record carries the freshness annotation (`as_of` / `lag_minutes` / `is_stale`), and your agent can request a refresh with `max_acceptable_lag_minutes`. **Q: Why can't I search by a person's name?** A: A GDPR re-identification guardrail, company search is CUI-only, plus case-number lookup. Private-individual parties appear pseudonymized in the output too. **Q: What is the `is_penal` flag?** A: A **legal fact**, that the matter is a penal one (tried under the Penal Code). It is NOT an accusation about any party; it is surfaced for due-diligence weighting. **Q: Can I get the real names of private individuals?** A: No, they are pseudonymized by design. Companies, PFA/ÎI/IF, and public institutions appear under their real names. **Q: Can I use the data in a commercial product?** A: Yes, court records are public. You can't resell the raw data as a competing portal.just.ro API. **Q: How do I control spend?** A: Pay-per-event, per case returned / per cause-list, no subscription. Set per-run and monthly spend limits in Apify Console. NOT\_FOUND cases and empty results are not billed. **Q: How is this different from the free portal.just.ro portal?** A: Litigation search by CUI (not just name/number), in bulk, MCP-native, pseudonymized by design, with API/CSV export, in one call, callable by an agent. *Version 1.0 · Updated June 2026* *** # Actor input Schema ## `caseNumbers` (type: `array`): Court case file numbers to look up, e.g. "6597/2/2021" (optionally with an annex suffix "6597/2/2021/a1"). Each resolves to one case record. Max 100 per run; a cache miss triggers a quota-bounded on-demand portal.just.ro fetch. ## `companyCuis` (type: `array`): Romanian company tax codes (CUI) whose litigation to search. Accepts "14399840", "RO14399840", or "RO 14399840", all are normalized. The orchestrator resolves each CUI to its legal name and searches cases by that name; there is NO free-text party-name input (the re-identification guardrail). Max 100 per run; each search returns up to 1000 cases. ## `court` (type: `string`): Optional court to narrow the company-CUI search, e.g. "Curtea de Apel București" or "Tribunalul Cluj" (diacritics optional; matched to the official ECRIS court list, or pass the portal.just.ro token directly). Applies to companyCuis only, case-number lookups are already court-specific. An unrecognized court name skips every companyCuis search with INVALID\_INPUT, so leave it blank to search all courts. ## `periodStart` (type: `string`): Optional lower bound on case registration date for the company-CUI search, a date "2024-01-01" or an offset-aware ISO datetime "2024-01-01T00:00:00Z". Applies to companyCuis only. ## `periodEnd` (type: `string`): Optional upper bound on case registration date for the company-CUI search, a date "2024-12-31" (inclusive of the whole day) or an offset-aware ISO datetime. Applies to companyCuis only. ## `maxAcceptableLagMinutes` (type: `integer`): Optional hard-staleness bound. When a cached result was fetched longer ago than this, the actor re-fetches from portal.just.ro (quota-bounded) rather than serving the cached rows. Omit to accept the default cache freshness. ## Actor input object example ```json { "caseNumbers": [ "6597/2/2021" ], "companyCuis": [] } ``` # Actor output Schema ## `cases` (type: `string`): All court case 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "caseNumbers": [ "6597/2/2021" ], "companyCuis": [] }; // Run the Actor and wait for it to finish const run = await client.actor("apnoda/portal-just").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "caseNumbers": ["6597/2/2021"], "companyCuis": [], } # Run the Actor and wait for it to finish run = client.actor("apnoda/portal-just").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 '{ "caseNumbers": [ "6597/2/2021" ], "companyCuis": [] }' | apify call apnoda/portal-just --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=apnoda/portal-just", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Romanian Courts Case Lookup (portal.just.ro)", "description": "Romanian court case lookup from portal.just.ro for due diligence: search a company's litigation by CUI, look up a case by file number, or pull a court's cause-list for a date. Penal-matter flag, procedural stage, MCP-native, pay-per-event. Private individuals pseudonymized by design.", "version": "0.1", "x-build-id": "KVCBhZBydWr2wzH6Z" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/apnoda~portal-just/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-apnoda-portal-just", "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~portal-just/runs": { "post": { "operationId": "runs-sync-apnoda-portal-just", "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~portal-just/run-sync": { "post": { "operationId": "run-sync-apnoda-portal-just", "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": { "caseNumbers": { "title": "Case file numbers", "maxItems": 100, "uniqueItems": true, "type": "array", "description": "Court case file numbers to look up, e.g. \"6597/2/2021\" (optionally with an annex suffix \"6597/2/2021/a1\"). Each resolves to one case record. Max 100 per run; a cache miss triggers a quota-bounded on-demand portal.just.ro fetch.", "items": { "type": "string", "minLength": 1, "maxLength": 64 }, "default": [] }, "companyCuis": { "title": "Company tax codes (CUI)", "maxItems": 100, "uniqueItems": true, "type": "array", "description": "Romanian company tax codes (CUI) whose litigation to search. Accepts \"14399840\", \"RO14399840\", or \"RO 14399840\", all are normalized. The orchestrator resolves each CUI to its legal name and searches cases by that name; there is NO free-text party-name input (the re-identification guardrail). Max 100 per run; each search returns up to 1000 cases.", "items": { "type": "string", "pattern": "^(?:[Rr][Oo]\\s*)?[0-9]{2,10}$" }, "default": [] }, "court": { "title": "Court filter (optional)", "type": "string", "description": "Optional court to narrow the company-CUI search, e.g. \"Curtea de Apel București\" or \"Tribunalul Cluj\" (diacritics optional; matched to the official ECRIS court list, or pass the portal.just.ro token directly). Applies to companyCuis only, case-number lookups are already court-specific. An unrecognized court name skips every companyCuis search with INVALID_INPUT, so leave it blank to search all courts." }, "periodStart": { "title": "Registered on/after (optional)", "type": "string", "description": "Optional lower bound on case registration date for the company-CUI search, a date \"2024-01-01\" or an offset-aware ISO datetime \"2024-01-01T00:00:00Z\". Applies to companyCuis only." }, "periodEnd": { "title": "Registered on/before (optional)", "type": "string", "description": "Optional upper bound on case registration date for the company-CUI search, a date \"2024-12-31\" (inclusive of the whole day) or an offset-aware ISO datetime. Applies to companyCuis only." }, "maxAcceptableLagMinutes": { "title": "Max acceptable cache lag (minutes)", "minimum": 1, "type": "integer", "description": "Optional hard-staleness bound. When a cached result was fetched longer ago than this, the actor re-fetches from portal.just.ro (quota-bounded) rather than serving the cached rows. Omit to accept the default cache freshness." } } }, "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 } } } } } } } } } } ```