# Sanctions Screening & Denied Party Check (OFAC) (`reliable_tools/sanctions-screening`) Actor

Sanctions screening and denied party screening against official OFAC, BIS Entity List, UK and EU lists. Calibrated match probability cuts false positives.

- **URL**: https://apify.com/reliable_tools/sanctions-screening.md
- **Developed by:** [Reliable Tools](https://apify.com/reliable_tools) (community)
- **Categories:** Developer tools, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.50 / 1,000 party screeneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## Sanctions Screening & Denied Party Screening (OFAC, UK, EU, BIS)

This sanctions screening and denied party screening Actor checks customers, suppliers and business partners against the official sanctions and export control lists of the US, the UK and the EU. Each party gets a clear status of clear, review or likely match, every candidate hit with its list name, entry ID, programs and official source link, and a probability that the hit really is the same party. That probability is what cuts the flood of false positives that simple name matching produces.

The hard part of sanctions screening is not finding similar names. It is the flood of false positives. A customer
called Mohammad Hassan, born 1990 and living in Germany, matches dozens of listed people on name alone. This Actor first
finds every similar name in code (spelling variants, transliteration, word order, aliases), then compares all the
attributes you know: date of birth, country, type of party, address and ID numbers. Each candidate gets a calibrated
probability, and the decision rules are fixed in code, so a name-only hit is never silently cleared and a conflicting
date of birth is never ignored.

This product uses the International Trade Administration's Data API but is not endorsed or certified by the
International Trade Administration. Not affiliated with or endorsed by OFAC, the U.S. Department of Commerce, the UK
FCDO or the European Commission.

**This is a screening aid, not legal advice.** It helps a person decide faster. Final decisions on any hit must be made
by a qualified human in your organisation.

### Who uses it

- Exporters and freight forwarders who need a denied-party check (BIS Entity List, Denied Persons, OFAC) before shipping.
- E-commerce sellers and brands that pay suppliers abroad and want a record that they checked them.
- Fintechs, marketplaces and payment teams screening merchants and payees in batches.
- German and EU companies doing their Sanktionslistenprüfung for customers and suppliers.
- Compliance teams who want fewer false positives in their review queue, with the evidence for each decision.

### Lists screened

| Key | List | Publisher |
|---|---|---|
| `ofac_sdn` | OFAC Specially Designated Nationals (SDN) List | US Treasury, OFAC |
| `ofac_consolidated` | OFAC Consolidated (non-SDN) List: SSI, FSE, NS-MBS, CMIC, PLC and others | US Treasury, OFAC |
| `us_csl` | US Consolidated Screening List: BIS Entity List, Denied Persons List, Unverified List, Military End User List, State Department ITAR Debarred and Nonproliferation Sanctions | US Department of Commerce, ITA |
| `uk` | UK Sanctions List | UK Foreign, Commonwealth & Development Office |
| `eu` | EU Consolidated Financial Sanctions List | European Commission |

The UN Security Council Consolidated List is not screened. The UN website terms allow its data only for personal,
non-commercial use, which a paid screening tool cannot meet. The EU and UK lists implement UN Security Council
designations, so UN-listed parties are normally on those lists too.

Every list is downloaded fresh from the official government source at the start of each run. The OFAC lists come
straight from OFAC; from the Consolidated Screening List the Actor only takes the Commerce and State Department lists, so
OFAC entries are not counted twice. In a test on 29 October 2026 the six lists held 39,879 records with 105,734 names and
aliases.

### What you get

**One row per party**

| Field | What it means |
|---|---|
| `reference`, `partyName`, `partyType`, `partyCountry`, `partyDateOfBirth` | What you sent in |
| `status` | `clear` (no candidate, or all cleared), `review` (a human should look) or `likely_match` |
| `highestProbability` | The highest probability among the candidates that the party is the listed one |
| `summary` | One sentence for your review queue |
| `candidatesFound`, `candidatesNeedingReview` | How many similar names were checked, and how many were not cleared |
| `filteredByType` | Similar names skipped because the listed type differs (for example a vessel when you screen a person) |
| `candidates` | The full list, described below |

**Each candidate**

| Field | What it means |
|---|---|
| `status` | `likely_match`, `review` or `cleared` |
| `sameEntityProbability` | Probability from 0 to 1 that the party and the listed entry are the same real-world party |
| `matchStrength` | A score from 0 to 4 with a level: `different`, `weak`, `name_only`, `strong` or `confirmed` |
| `nameVariantProbability`, `attributeConflictProbability` | Is the name really the same name, and does any attribute conflict |
| `list`, `listName`, `entryId`, `listedName` | Which list, which entry, under which name |
| `programs`, `listedOn` | Sanctions programs or regimes, and the listing date where published |
| `sourceUrl`, `legalBasisUrl` | Link to the official entry or list page, and for EU entries the legal act |
| `evidence` | Side by side: name and name similarity, date of birth, country, type, ID numbers and addresses, each with a result such as `match`, `partial`, `conflict`, `differs` or `unknown` |

**Audit summary for your compliance file**

Each run also saves an `AUDIT` record in the key-value store (linked in the Output tab): start and end time, run ID, the
publication date of every list version used, record counts, the SHA-256 hash of every downloaded file, counts per status,
your thresholds and a short description of the method. Keep it next to the results and you can show which list version
each decision was based on.

### How the decision works

1. **Candidates.** Names on both sides are converted to Latin letters (Cyrillic, Arabic and others), legal-form words
   like LLC, GmbH or OOO are removed, and every listed name and alias is compared word-order free, with tolerance for
   spelling variants such as Mohammed and Muhammad. Names at or above the minimum similarity become candidates.
2. **Attribute check.** Each candidate is compared with everything you gave for the party. Date of birth, country and ID
   numbers are compared in code and passed on with the full listed record.
3. **Probability.** An AI check answers four fixed questions per candidate: same party or not, how strong the evidence
   is, whether the name is really the same name, and whether an attribute conflicts. All answers are probabilities.
4. **Rules in code.**
   - `likely_match` needs a probability at or above your threshold (0.75 by default) **and** strong evidence beyond the
     name.
   - A name-only hit with nothing to rule it out goes to `review`, never to `cleared`.
   - A conflicting date of birth caps the probability at 0.1.
   - A weak name match with a clear attribute conflict and a probability under 0.3 is `cleared`.
   - Anything the check could not finish goes to `review`.

### How to run it

1. Add your parties in **Parties to screen**. Only `name` is required:

```json
[
  {"reference": "C-1001", "name": "Mohammad Hassan", "type": "individual", "country": "DE", "dateOfBirth": "1990-05-01"},
  {"reference": "S-2002", "name": "Rosneft Oil Company", "type": "entity", "country": "RU"},
  {"reference": "S-2003", "name": "Siemens AG", "type": "entity", "country": "DE"}
]
```

Optional fields: `type` (individual, entity, vessel, aircraft), `country`, `dateOfBirth` (YYYY-MM-DD or YYYY),
`address`, `idNumber`, `aliases` (a list) and `reference` (your own ID, returned unchanged).
2\. Keep all lists selected for a full screen, or pick the ones your policy requires.
3\. Start the run. A batch of a few parties finishes in well under a minute, most of it spent downloading the lists.
Larger batches add only seconds per party.
4\. Filter the results by `status`. Work through `likely_match` and `review`, and file the `AUDIT` record.

You can also call the Actor from your own system through the Apify API and screen every new customer or supplier as it
comes in.

### Example output

The three parties above, run on 29 October 2026:

| Party | Status | Top probability | Summary |
|---|---|---|---|
| Mohammad Hassan (individual, DE, born 1990) | `review` | 0.40 | 8 similar names found, 7 cleared, 1 left for a human look |
| Rosneft Oil Company (entity, RU) | `likely_match` | 0.99 | Listed on the BIS Entity List, OFAC SDN, OFAC non-SDN (SSI) and the UK Sanctions List |
| Siemens AG (entity, DE) | `clear` | 0 | No similar names on the screened lists |

For Mohammad Hassan, seven of the eight name hits had a different year of birth and were cleared at 0.04 to 0.06. One
stayed in review: a listed person with the exact alias "Muhammad Hassan" and no date of birth on the list, so only the
country speaks against it. That one, shortened:

```json
{
  "status": "review",
  "sameEntityProbability": 0.4,
  "matchStrength": {"score": 0.99, "level": "weak", "confidence": 0.17},
  "nameVariantProbability": 0.7,
  "attributeConflictProbability": 0.9,
  "list": "uk",
  "listName": "UK Sanctions List",
  "entryId": "SYR0409",
  "listedName": "Mohammad Hassan Kanjou",
  "programs": ["Asset freeze|Travel Ban|Director Disqualification Sanction", "The Syria (Sanctions) (EU Exit) Regulations 2019"],
  "listedOn": "2023-12-07",
  "evidence": {
    "name": {"party": "Mohammad Hassan", "list": "Muhammad Hassan", "nameScore": 93.3},
    "dateOfBirth": {"party": "1990-05-01", "list": [], "result": "unknown"},
    "country": {"party": "DE", "list": ["SY"], "result": "differs"},
    "entityType": {"party": "individual", "list": "individual", "result": "match"}
  }
}
```

When we screened "Vladimir Putin" with his date of birth, the OFAC, UK and EU entries came back as `likely_match` at
0.99, and a similar name with a different date of birth (Vladimir Tyurin) was cleared at 0.03.

### How to use the sanctions screening Actor via API

You can run the sanctions screening Actor in the Apify Console, or call it from your own code through the Apify API. The **API** tab of this Actor has ready-to-copy examples for the JavaScript and Python API clients, the Apify CLI, plain HTTP and the OpenAPI definition. To use it from an AI assistant or agent, connect the Apify MCP server and add this Actor as a tool.

Send the same JSON input you would fill in the form, for example a list of parties with name, type, country and date of birth, start a run, and read the results from the run's default dataset as JSON, CSV or Excel. You can also schedule runs in Apify.

### Pricing

You pay per event and there's no subscription. Each screened party is one "party screened" event, whether it comes back
clear or not, and that price includes the attribute check of all its candidates. If a candidate check fails, that party
row is free and marked for review. A run that cannot download a list stops before screening and charges nothing beyond
the small start fee.

### Tips

- Give a date of birth and country for people, and a country and registration number for companies. Most false
  positives are cleared by those two fields alone.
- Name-only screens (the **Quick list of names** field) work, but more hits will land in `review`, because there is
  nothing to rule them out.
- Lower **Minimum name similarity** to 80 if your data has many spelling variants. You will get more candidates to check.
- Lower **Review from probability** if your policy is very cautious. Cleared candidates always stay in the output with
  their probability, so nothing is hidden.
- `review` hits on related companies (for example subsidiaries of a listed group in other countries) are worth a look:
  ownership rules such as the OFAC 50% rule can apply to entities that are not listed by name.
- Screen again whenever the lists change. Schedule the Actor daily or weekly on your customer and supplier lists.

### FAQ

**Is this legal advice?** No. This is a screening aid. It does not decide whether a transaction is allowed, and it does
not replace your compliance program, a licence check or a lawyer. Every `likely_match` and `review` needs a decision by
a qualified person, and that person should confirm the hit on the official list before acting.

**Where does the data come from, and may it be used?** Only from official public sources, downloaded fresh for every
run. OFAC lists and the US Consolidated Screening List are works of the US Government and are in the public domain.
This product uses the International Trade Administration's Data API but is not endorsed or certified by the
International Trade Administration. The UK Sanctions List contains public sector information licensed under the Open
Government Licence v3.0. The EU list is published by the European Commission for reuse with source acknowledgement. No
commercial or third-party sanctions databases are used.

**How current are the lists?** As current as the official files at the moment your run starts. The publication date of
each list is in the `AUDIT` record. OFAC and the UK update their files often, sometimes daily; the EU file is
updated whenever a change is published.

**What about personal data and GDPR?** Parties can be individuals, so your input is personal data. Screening customers
and suppliers against sanctions lists is usually based on a legal obligation or your legitimate interest (GDPR Article 6
(1)(c) or (f)), but you are responsible for your own legal basis. The Actor only uses the fields you send, does not
enrich them from other sources and does not log names. To score each candidate, the party fields you send and the
candidate list entries are sent to our AI processing provider in the USA, which processes them for that score under its
data processing terms (these include the EU Standard Contractual Clauses). We keep nothing after the run; the results
stay in your own Apify storage. Send only the fields you need, and delete runs you no longer need or set a short data retention in your
Apify settings.

**Does it cover PEPs or adverse media?** No. It covers sanctions and export control lists only.

**Does it check ownership (50% rule)?** No. It screens the names you send. If you know the owners of a company, add them
as separate parties.

**How accurate is it?** Every candidate comes with a probability and the evidence compared, so you can check each one in
seconds. In our tests, clear cases on both sides were decided with probabilities near 0.99 or near 0.05, and name-only
hits went to review. Like any screening tool it can miss a party listed under a name that is very different from the
one you have, so keep aliases in your data.

**How do I run an OFAC search for many names at once?** Add your parties, or paste names into the **Quick list of names** field, and keep the `ofac_sdn` and `ofac_consolidated` lists selected. Each name is checked against every OFAC entry and alias in one run.

**What is denied party screening, and which lists does it cover?** It checks a party against export control lists before you ship or pay. This Actor covers the US Consolidated Screening List from Commerce and State (BIS Entity List, Denied Persons List, Unverified List, Military End User List, ITAR Debarred and Nonproliferation Sanctions) next to the OFAC, UK and EU sanctions lists.

**Can I use it for a Sanktionslistenprüfung in Germany?** Yes. It screens against the EU Consolidated Financial Sanctions List as well as the UK and US lists, and saves an `AUDIT` record with the version of every list used, so you can document the check.

**Something broke or a list failed to load?** Open an issue on the Issues tab and we'll look at it.

### About Reliable Tools

This Actor is made by [Reliable Tools](https://apify.com/reliable_tools). We build tools that return clean data plus a
calibrated AI check with a probability, so you can filter and act on the results straight away.

If a result looks wrong or a list doesn't load the way you expect, open an issue on the Issues tab. We read every one
and usually reply within a day. You can find our other Actors on our [profile page](https://apify.com/reliable_tools).

# Actor input Schema

## `parties` (type: `array`):

One object per customer, supplier or partner. Only "name" is required. Optional: "type" (individual, entity, vessel, aircraft), "country" (name or ISO code), "dateOfBirth" (YYYY-MM-DD or YYYY, for individuals), "address", "idNumber" (passport, national ID, company registration or IMO number), "aliases" (list of other names) and "reference" (your own ID, returned as is). Every extra attribute helps clear false positives.

## `names` (type: `array`):

Optional shortcut: one name per line, screened with no other attributes. Use "Parties" above when you know the country, date of birth or ID, so fewer names end up in review.

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

Official lists, downloaded fresh from each government source for every run. Leave all selected for a full denied-party screen. The UN Security Council list is not offered: the UN website terms allow its data only for personal, non-commercial use. The EU and UK lists already implement UN Security Council designations.

## `minNameScore` (type: `integer`):

How close a listed name must be to become a candidate. Lower finds more spelling variants and more noise; 85 is a good balance.

## `maxCandidatesPerParty` (type: `integer`):

The closest listed names per party that get the full attribute check.

## `likelyMatchThreshold` (type: `string`):

A candidate at or above this probability of being the same party is marked likely_match.

## `reviewThreshold` (type: `string`):

Candidates between this value and the likely match value go to review. Exact name matches with nothing to rule them out always go to review. Lower is more cautious.

## Actor input object example

```json
{
  "parties": [
    {
      "reference": "C-1001",
      "name": "Mohammad Hassan",
      "type": "individual",
      "country": "DE",
      "dateOfBirth": "1990-05-01"
    },
    {
      "reference": "S-2002",
      "name": "Rosneft Oil Company",
      "type": "entity",
      "country": "RU"
    },
    {
      "reference": "S-2003",
      "name": "Siemens AG",
      "type": "entity",
      "country": "DE"
    }
  ],
  "lists": [
    "ofac_sdn",
    "ofac_consolidated",
    "us_csl",
    "uk",
    "eu"
  ],
  "minNameScore": 85,
  "maxCandidatesPerParty": 8,
  "likelyMatchThreshold": "0.75",
  "reviewThreshold": "0.2"
}
```

# Actor output Schema

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

Dataset in the screening results view.

## `audit` (type: `string`):

Run timestamp, list versions and publication dates, file hashes, counts and settings.

# 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 = {
    "parties": [
        {
            "reference": "C-1001",
            "name": "Mohammad Hassan",
            "type": "individual",
            "country": "DE",
            "dateOfBirth": "1990-05-01"
        },
        {
            "reference": "S-2002",
            "name": "Rosneft Oil Company",
            "type": "entity",
            "country": "RU"
        },
        {
            "reference": "S-2003",
            "name": "Siemens AG",
            "type": "entity",
            "country": "DE"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("reliable_tools/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 = { "parties": [
        {
            "reference": "C-1001",
            "name": "Mohammad Hassan",
            "type": "individual",
            "country": "DE",
            "dateOfBirth": "1990-05-01",
        },
        {
            "reference": "S-2002",
            "name": "Rosneft Oil Company",
            "type": "entity",
            "country": "RU",
        },
        {
            "reference": "S-2003",
            "name": "Siemens AG",
            "type": "entity",
            "country": "DE",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("reliable_tools/sanctions-screening").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "parties": [
    {
      "reference": "C-1001",
      "name": "Mohammad Hassan",
      "type": "individual",
      "country": "DE",
      "dateOfBirth": "1990-05-01"
    },
    {
      "reference": "S-2002",
      "name": "Rosneft Oil Company",
      "type": "entity",
      "country": "RU"
    },
    {
      "reference": "S-2003",
      "name": "Siemens AG",
      "type": "entity",
      "country": "DE"
    }
  ]
}' |
apify call reliable_tools/sanctions-screening --silent --output-dataset

```

## MCP server setup

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

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Va5dq0Ak9DsY0aJgz/builds/PO3sTAtVNhhX3uqt8/openapi.json