# Romanian Company Sanctions Screening (EU, OFAC, UN, UK, SECO) (`apnoda/sanctions-screening`) Actor

Screen a Romanian company by CUI against the official EU (FSF), OFAC (SDN + Consolidated), UN, UK (FCDO) and Swiss SECO sanctions lists. Returns CLEAR / POSSIBLE\_MATCH / MATCH, confidence-scored. CUI-only input, deterministic (no LLM), MCP-native. No PEP screening.

- **URL**: https://apify.com/apnoda/sanctions-screening.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 $70.00 / 1,000 sanctions screen 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

## Screening Sancțiuni Firme România (EU FSF + OFAC + UN + UK + SECO)

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

---

### Română

**Screening de sancțiuni pentru o firmă românească, după CUI, împotriva listelor oficiale EU FSF, OFAC, UN, UK și SECO (Elveția).** Returnează `CLEAR` / `POSSIBLE_MATCH` / `MATCH` cu detaliu scorat pe încredere. Input exclusiv CUI (fără căutare după nume), potrivire deterministă (fără LLM), nativ-MCP, plată pe eveniment.

#### Ce face acest Actor

Rezolvă intern denumirea legală a firmei din CUI și o potrivește (string fuzzy + normalizare prin transliterare) împotriva câmpurilor de nume/alias din:

- **EU FSF** (Financial Sanctions Files, DG FISMA): lista direct aplicabilă pentru o contraparte din RO (drept UE). **Lista primară.**
- **OFAC**: SDN + Consolidated (model „advanced"), pentru contrapărți cu expunere SUA.
- **UN SC**: Lista consolidată a Consiliului de Securitate ONU.
- **UK** (UK Sanctions List, FCDO): regimul de sancțiuni britanic post-Brexit, relevant pentru exportatorii RO cu expunere UK.
- **SECO** (Elveția, lista consolidată): regimul elvețian, pentru contrapărți cu expunere în Elveția.

Ecranul curat ESTE produsul: pentru due-diligence, un rezultat „fără potrivire" este livrabilul, deci se taxează identic cu o potrivire. NU există un eveniment separat `match_found` (taxarea doar pe potriviri ar inversa modelul de venit).

⚠️ **Fără screening PEP** (persoane expuse politic) și **fără adverse media**, nu există o sursă oficială gratuită; sunt în afara scopului, declarat, nu omis tacit. Un `POSSIBLE_MATCH` este un semnal de similaritate de nume pentru verificare împotriva listei oficiale, **niciodată** o determinare că entitatea este sancționată.

#### Cum se citește rezultatul

| Status | Ce înseamnă | Ce faci |
|---|---|---|
| **`CLEAR`** | Nicio potrivire peste pragul de similaritate față de listele selectate. | Ecranul curat e livrabilul. Păstrează rezultatul (cu `screened_against[].as_of`) ca dovadă de due-diligence. |
| **`POSSIBLE_MATCH`** | Similaritate de nume în banda 0.85–sub 0.93, posibilă, de verificat. | **Verifică manual** numele rezolvat și `matches[]` (program, listă, `reference_number`) împotriva listei oficiale înainte de orice decizie. |
| **`MATCH`** | Similaritate ridicată (≥0.93). | Tratează ca semnal puternic; **tot verifici** împotriva sursei oficiale și consulți compliance/juridic. Nu acționezi exclusiv pe baza acestui rezultat. |

Fiecare rezultat include `resolved_entity` (denumirea legală + alias-uri/administratori, câmpuri rezervate și dormante în v1), `screened_against[]` (`as_of` per listă plus un `is_stale` la nivel de instantaneu), `matches[]` scorate și un `disclaimer`. Potrivirea e deterministă: aceeași intrare → același rezultat.

#### Utilizare MCP

```json
{
  "mcpServers": {
    "sanctions-screening": {
      "url": "https://mcp.apify.com?tools=apnoda/sanctions-screening"
    }
  }
}
````

| Unealtă | Ce face |
|---|---|
| **`screen_sanctions`** | Screenează o firmă după CUI împotriva listelor EU / OFAC / UN / UK / SECO. Returnează `cui`, `resolved_entity`, `screened_against[]` (prospețime per listă), `status`, `matches[]` și un `disclaimer`. Opțional: selecția listelor (`lists`), pragul de potrivire (`match_threshold`, doar mai strict de 0.85) și un prag dur de prospețime (`max_acceptable_lag_minutes`). |
| **`get_sanctions_freshness`** | Gratuit, netaxat. Verifică pregătirea și prospețimea listelor înainte de a plăti un screening: returnează `ready`, `ingested_at`, `age_minutes`, `is_stale` și `lists[]` (fiecare listă cu `as_of`-ul sursei). Fără input, fără taxare. |

Rularea ca task (dataset) acceptă o listă de până la **100 CUI-uri** pe rulaj.

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

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

- **Pornire Actor** (`actor_start`): **$0.01**, o dată per rulaj / pornire la rece în standby. În uz MCP standby „cald", screening-urile succesive nu re-taxează pornirea.
- **Per screening completat** (`screen_completed`): **$0.07**, evenimentul principal, taxat pe orice screening finalizat (CLEAR, POSSIBLE\_MATCH sau MATCH). CUI-urile nerezolvabile (NOT\_FOUND) **nu se taxează**.

Exemple de cost:

| Scenariu | Calcul | Total |
|---|---|---|
| Verificare unică a unei contrapărți | $0.01 + 1 × $0.07 | **$0.08** |
| Onboarding a 50 de contrapărți (un rulaj dataset) | $0.01 + 50 × $0.07 | **$3.51** |
| 500 de contrapărți (o sesiune MCP standby „caldă") | $0.01 + 500 × $0.07 | **$35.01** |
| Re-screening lunar a 200 de contrapărți (o sesiune MCP „caldă") | $0.01 + 200 × $0.07 | **$14.01 / lună** |

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, ex. 500 = 5 rulaje = $35.05), fie o singură sesiune MCP standby „caldă" (o pornire, multe screening-uri, așa cum presupun rândurile de 500 și 200 de mai sus).

Costurile de platformă/calcul sunt absorbite în prețul evenimentului, nu se taxează separat.

#### Comparație cu alternativele

| | apnoda sanctions-screening | OpenSanctions (date deschise) | Verificare manuală (portaluri oficiale) | Suite enterprise (World-Check / Dow Jones / LexisNexis) |
|---|---|---|---|---|
| Liste | EU FSF + OFAC + UN + UK + SECO | EU + OFAC + UN + PEP + multe | aceleași, dar manual | + PEP + adverse media + multe alte liste |
| Intrare | **CUI** (nativ RO); numele rezolvat intern | nume / entitate | nume, manual | nume / ID |
| Interfață | **nativ-MCP** + dataset | API / bulk / self-host | formulare web | portal / API enterprise |
| Potrivire | deterministă (fuzzy + transliterare) | proprie (yente) | ochiul uman | proprietară |
| Preț | **$0.07 / screening**, fără abonament | gratuit (necomercial); licență pentru uz comercial | gratuit, dar lent/manual | contract anual, $$$$ |
| Prospețime | reîmprospătare zilnică | orară/zilnică | live la sursă | continuă |
| Potrivit pentru | due-diligence programatic, la scară, ieftin, pe contrapărți RO | echipe care găzduiesc un dataset global | verificări ad-hoc, ocazionale | departamente mari de compliance |

**Onest:** acest Actor **nu înlocuiește** un program complet KYC/AML. Acoperă sancțiuni (EU/OFAC/UN/UK/SECO), nu PEP și nu adverse media. Pentru obligații de conformitate reglementate, folosește-l ca un strat rapid, ieftin și automatizabil, nu ca unic control.

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

**Un `MATCH` înseamnă că firma este sancționată?**
Nu. Înseamnă o similaritate de nume ridicată față de o intrare de pe o listă oficială. Verifică întotdeauna `matches[]` (listă, program, `reference_number`) împotriva sursei oficiale înainte de a acționa.

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

**Cât de proaspete sunt listele?**
Reîmprospătare zilnică (înlocuire integrală a instantaneului). Fiecare rezultat poartă `as_of` per listă și un indicator `is_stale`. Cu `max_acceptable_lag_minutes` poți cere o eroare dură (`SANCTIONS_DATA_STALE`) în loc de un rezultat posibil-învechit.

**Faceți screening PEP sau adverse media?**
Nu. Nu există o sursă oficială gratuită; sunt declarate în afara scopului, nu omise tacit.

**Pot screena o persoană fizică / un administrator?**
v1 potrivește la nivel de persoană juridică. Calea pentru persoane fizice există în contract, dar este dormantă.

**De ce un `CLEAR` se taxează la fel ca o potrivire?**
Pentru due-diligence, dovada „fără potrivire" ESTE livrabilul. Taxarea doar pe potriviri ar inversa modelul.

**Ce se întâmplă dacă CUI-ul nu se rezolvă?**
Status `NOT_FOUND`, **fără taxare**.

**Pot restrânge listele sau înăspri pragul?**
Da, `lists` (eu\_fsf / ofac / un\_sc / uk\_hmt / ch\_seco) și `match_threshold` (doar mai strict decât 0.85 implicit).

#### Sursa datelor și aspecte legale

- **EU FSF**: *Contains EU Financial Sanctions Files data © European Union, reused under Commission Decision 2011/833/EU; modified.* Reutilizare (inclusiv comercială) permisă; token public, fără cont.
- **OFAC**: operă a Guvernului SUA, domeniu public.
- **UN SC**: material ONU, liber utilizabil pentru conformitate.
- **UK**: UK Sanctions List (FCDO), Crown copyright, reutilizabil sub Open Government Licence v3.0. A înlocuit vechea listă consolidată OFSI (închisă în 28.01.2026).
- **SECO**: lista consolidată elvețiană (State Secretariat for Economic Affairs), date oficiale publice, liber utilizabile pentru conformitate.
- **Disclaimer:** rezultat de screening, nu consultanță juridică. Doar lista oficială a sursei (Jurnalul Oficial al UE, UK Sanctions List, OFAC, ONU sau SECO) este autentică, verifică orice potrivire împotriva listei oficiale.

#### Confidențialitate & date personale

apnoda-daas este operatorul de date; Apify, Cloudflare și Hetzner sunt persoane împuternicite (Art. 28).

- **Input exclusiv CUI**: fără căutare după nume (garda de re-identificare GDPR). Denumirea este rezolvată intern.
- **Potriviri la nivel de entitate juridică** în v1; calea pentru persoane fizice (administratori) este dormantă.
- Listele oficiale conțin nume de persoane sancționate. Le oglindim verbatim ca instantaneu (înlocuit integral la fiecare reîmprospătare, fără istoric); ștergerea (art. 17) a unei persoane încă listate este refuzabilă pe baza art. 17(3), remediul este delistarea la sursă, după care intrarea dispare automat la următoarea reîmprospătare.
- **DSR:** scrie la `privacy@apnoda.com`: răspuns în 30 de zile.

***

### English

**Sanctions screening for a Romanian company, by CUI, against the official EU FSF, OFAC, UN, UK, and Swiss (SECO) lists.** Returns `CLEAR` / `POSSIBLE_MATCH` / `MATCH` with confidence-scored detail. CUI-only input (no name search), deterministic matching (no LLM), MCP-native, pay-per-event.

#### What this Actor does

It resolves the company's legal name internally from the CUI and matches it (fuzzy string + transliteration normalization) against the name/alias fields of:

- **EU FSF** (Financial Sanctions Files, DG FISMA): the directly-applicable list for a Romanian counterparty (EU law). **Primary list.**
- **OFAC**: SDN + Consolidated (advanced model), for counterparties with US exposure.
- **UN SC**: the UN Security Council Consolidated List.
- **UK** (UK Sanctions List, FCDO): the post-Brexit UK regime, relevant for RO exporters with UK exposure.
- **SECO** (Switzerland, consolidated list): the Swiss regime, for counterparties with Swiss exposure.

The clean screen IS the product: for due diligence, a "no match found" result is the deliverable, so it bills identically to a hit. There is deliberately NO separate `match_found` event (charging only on hits would invert the revenue model).

⚠️ **No PEP screening** (politically exposed persons) and **no adverse media**, there is no free official source; both are out of scope, stated not silently absent. A `POSSIBLE_MATCH` is a name-similarity flag for verification against the official list, **never** a determination that the entity is sanctioned.

#### How to read the result

| Status | What it means | What you do |
|---|---|---|
| **`CLEAR`** | No match above the similarity threshold against the selected lists. | The clean screen is the deliverable. Keep the result (with `screened_against[].as_of`) as due-diligence evidence. |
| **`POSSIBLE_MATCH`** | Name similarity in the 0.85 to under 0.93 band, possible, to be verified. | **Manually verify** the resolved name and `matches[]` (program, list, `reference_number`) against the official list before any decision. |
| **`MATCH`** | High similarity (≥0.93). | Treat as a strong signal; **still verify** against the official source and consult compliance/legal. Do not act on this result alone. |

Every result includes `resolved_entity` (legal name; the aliases/directors fields are reserved, dormant in v1), `screened_against[]` (a per-list `as_of` plus a snapshot-wide `is_stale`), scored `matches[]`, and a `disclaimer`. Matching is deterministic: same input → same result.

#### MCP-first usage

```json
{
  "mcpServers": {
    "sanctions-screening": {
      "url": "https://mcp.apify.com?tools=apnoda/sanctions-screening"
    }
  }
}
```

| Tool | What it does |
|---|---|
| **`screen_sanctions`** | Screen a company by CUI against the EU / OFAC / UN / UK / SECO lists. Returns `cui`, `resolved_entity`, `screened_against[]` (per-list freshness), `status`, `matches[]`, and a `disclaimer`. Optional: list selection (`lists`), match threshold (`match_threshold`, tighten-only beyond 0.85), and a hard freshness bound (`max_acceptable_lag_minutes`). |
| **`get_sanctions_freshness`** | Free, unbilled. Check list readiness and freshness before paying for a screen: returns `ready`, `ingested_at`, `age_minutes`, `is_stale`, and `lists[]` (each list with its source `as_of`). No input, no charge. |

A task (dataset) run accepts a list of up to **100 CUIs** per run.

#### Pricing and cost calculator

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

- **Actor start** (`actor_start`): **$0.01**, once per run / standby cold boot. In warm MCP standby use, successive screens do not re-charge the start.
- **Per completed screen** (`screen_completed`): **$0.07**, the primary event, billed on any completed screen (CLEAR, POSSIBLE\_MATCH, or MATCH). CUIs that resolve to no entity (NOT\_FOUND) are **not billed**.

Cost examples:

| Scenario | Calculation | Total |
|---|---|---|
| One-off check of a single counterparty | $0.01 + 1 × $0.07 | **$0.08** |
| Onboarding 50 counterparties (one dataset run) | $0.01 + 50 × $0.07 | **$3.51** |
| 500 counterparties (one warm MCP standby session) | $0.01 + 500 × $0.07 | **$35.01** |
| Monthly re-screen of 200 counterparties (one warm MCP session) | $0.01 + 200 × $0.07 | **$14.01 / month** |

A **dataset/task run is capped at 100 CUIs** (one $0.01 start). For higher volumes: either multiple dataset runs (one $0.01 each, e.g. 500 = 5 runs = $35.05), or a single warm MCP standby session (one start, many screens, as the 500- and 200-CUI rows above assume).

Platform / compute costs are absorbed in the event price, never billed separately.

#### How it compares

| | apnoda sanctions-screening | OpenSanctions (open data) | Manual check (official portals) | Enterprise suites (World-Check / Dow Jones / LexisNexis) |
|---|---|---|---|---|
| Lists | EU FSF + OFAC + UN + UK + SECO | EU + OFAC + UN + PEP + many | same, but manual | + PEP + adverse media + many more lists |
| Input | **CUI** (RO-native); name resolved internally | name / entity | name, manual | name / ID |
| Interface | **MCP-native** + dataset | API / bulk / self-host | web forms | portal / enterprise API |
| Matching | deterministic (fuzzy + transliteration) | own (yente) | human eyeball | proprietary |
| Price | **$0.07 / screen**, no subscription | free (non-commercial); license for commercial | free, but slow/manual | annual contract, $$$$ |
| Freshness | daily refresh | hourly/daily | live at source | continuous |
| Best for | programmatic, at-scale, cheap DD on RO counterparties | teams self-hosting a global dataset | one-off ad-hoc checks | large compliance departments |

**Honest positioning:** this Actor **does not replace** a full KYC/AML program. It covers sanctions (EU/OFAC/UN/UK/SECO), not PEPs and not adverse media. For regulated compliance obligations, use it as a fast, cheap, automatable layer, not as your only control.

#### FAQ

**Does a `MATCH` mean the company is sanctioned?**
No. It means a high name-similarity to an entry on an official list. Always verify `matches[]` (list, program, `reference_number`) against the official source before acting.

**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.

**How fresh are the lists?**
Daily refresh (full snapshot swap). Every result carries a per-list `as_of` and an `is_stale` flag. With `max_acceptable_lag_minutes` you can demand a hard error (`SANCTIONS_DATA_STALE`) instead of a possibly-stale result.

**Do you screen PEPs or adverse media?**
No. There is no free official source; both are declared out of scope, not silently absent.

**Can I screen a natural person / director?**
v1 matches at the legal-entity level. The natural-person path exists in the contract but is dormant.

**Why is a `CLEAR` billed the same as a match?**
For due diligence, the "no match" evidence IS the deliverable. Charging only on hits would invert the model.

**What if the CUI doesn't resolve?**
Status `NOT_FOUND`, **not billed**.

**Can I restrict the lists or tighten the threshold?**
Yes, `lists` (eu\_fsf / ofac / un\_sc / uk\_hmt / ch\_seco) and `match_threshold` (tighten-only beyond the 0.85 default).

#### Data source and legal

- **EU FSF**: *Contains EU Financial Sanctions Files data © European Union, reused under Commission Decision 2011/833/EU; modified.* Reuse (including commercial) permitted; public token, no account.
- **OFAC**: a US Government work, public domain.
- **UN SC**: UN material, freely usable for compliance.
- **UK**: UK Sanctions List (FCDO), Crown copyright, reusable under the Open Government Licence v3.0. It superseded the legacy OFSI consolidated list (closed 2026-01-28).
- **SECO**: the Swiss consolidated list (State Secretariat for Economic Affairs), official public data, freely usable for compliance.
- **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.

#### Privacy & personal data

apnoda-daas is the data controller; Apify, Cloudflare, and Hetzner are Article 28 processors.

- **CUI-only input**: no name search (the GDPR re-identification guardrail). The name is resolved internally.
- **Legal-entity-level matches** in v1; the natural-person (director) path is dormant.
- The official lists contain names of sanctioned persons. We mirror them verbatim as a snapshot (replaced wholesale on each refresh, no history); erasure (Art. 17) of a still-listed person is refusable under Art. 17(3), the remedy is delisting at the source, after which the entry drops automatically on the next refresh.
- **Data Subject Requests:** write to `privacy@apnoda.com`: answered within 30 days.

***

*apnoda · privacy@apnoda.com*

# Actor input Schema

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

Romanian company tax codes (CUI) to screen. Accepts any common form: "14399840", "RO14399840", or "RO 14399840", the actor normalizes all three. Each is screened against the lists selected below (all of them by default). Max 100 CUIs per run.

## `lists` (type: `array`):

Which list families to screen against. Omit to screen all of them (recommended, the default). "OFAC" expands to both OFAC advanced lists (SDN + Consolidated); the precise per-list id is surfaced in each match. Narrowing this checks fewer lists, use it only when a specific-list screen is required.

## `maxAcceptableLagMinutes` (type: `integer`):

Optional hard-staleness bound on the sanctions-list snapshots. A screen against a snapshot older than this (or of unknown age) is rejected with SANCTIONS\_DATA\_STALE rather than returned as a possibly-false-clean result. Omit to accept the default ~24h list-refresh freshness (older snapshots are flagged is\_stale but still returned).

## Actor input object example

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

# Actor output Schema

## `screens` (type: `string`):

All screening results from 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/sanctions-screening").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/sanctions-screening").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/sanctions-screening --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Romanian Company Sanctions Screening (EU, OFAC, UN, UK, SECO)",
        "description": "Screen a Romanian company by CUI against the official EU (FSF), OFAC (SDN + Consolidated), UN, UK (FCDO) and Swiss SECO sanctions lists. Returns CLEAR / POSSIBLE_MATCH / MATCH, confidence-scored. CUI-only input, deterministic (no LLM), MCP-native. No PEP screening.",
        "version": "0.1",
        "x-build-id": "rvgjZikr4DMV8I2rA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/apnoda~sanctions-screening/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-apnoda-sanctions-screening",
                "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~sanctions-screening/runs": {
            "post": {
                "operationId": "runs-sync-apnoda-sanctions-screening",
                "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~sanctions-screening/run-sync": {
            "post": {
                "operationId": "run-sync-apnoda-sanctions-screening",
                "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",
                "required": [
                    "cuis"
                ],
                "properties": {
                    "cuis": {
                        "title": "Company tax codes (CUI)",
                        "maxItems": 100,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Romanian company tax codes (CUI) to screen. Accepts any common form: \"14399840\", \"RO14399840\", or \"RO 14399840\", the actor normalizes all three. Each is screened against the lists selected below (all of them by default). Max 100 CUIs per run.",
                        "items": {
                            "type": "string",
                            "pattern": "^(?:[Rr][Oo]\\s*)?[0-9]{2,10}$"
                        },
                        "default": []
                    },
                    "lists": {
                        "title": "Sanctions lists to screen",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which list families to screen against. Omit to screen all of them (recommended, the default). \"OFAC\" expands to both OFAC advanced lists (SDN + Consolidated); the precise per-list id is surfaced in each match. Narrowing this checks fewer lists, use it only when a specific-list screen is required.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "eu_fsf",
                                "ofac",
                                "un_sc",
                                "uk_hmt",
                                "ch_seco"
                            ],
                            "enumTitles": [
                                "EU FSF",
                                "OFAC (SDN + Consolidated)",
                                "UN Security Council",
                                "UK Sanctions List",
                                "Switzerland (SECO)"
                            ]
                        }
                    },
                    "maxAcceptableLagMinutes": {
                        "title": "Max acceptable list lag (minutes)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional hard-staleness bound on the sanctions-list snapshots. A screen against a snapshot older than this (or of unknown age) is rejected with SANCTIONS_DATA_STALE rather than returned as a possibly-false-clean result. Omit to accept the default ~24h list-refresh freshness (older snapshots are flagged is_stale but still returned)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
