# Sanctions Screening – OFAC, UN, EU & UK Lists (Fuzzy KYC) (`yck69/sanctions-screening`) Actor

Screen people and companies against the official OFAC SDN, UN Security Council, EU and UK sanctions lists, downloaded fresh on every run. Fuzzy name matching across aliases and transliterations, date-of-birth and country checks, risk level and evidence for every hit.

- **URL**: https://apify.com/yck69/sanctions-screening.md
- **Developed by:** [yck](https://apify.com/yck69) (community)
- **Categories:** Lead generation
- **Features:** Limited permissions
- **Stats:** 8 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $5.00 / 1,000 name screeneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 – OFAC, UN, EU & UK Lists (Fuzzy KYC)

https://www.youtube.com/watch?v=LXdeVLdEAIU

**What does Sanctions Screening do?** It checks people and companies against the four main official sanctions lists — **US OFAC SDN, UN Security Council, EU consolidated list and UK sanctions list** — and tells you, name by name, whether there is a potential match, how strong it is and why. Every list is downloaded **fresh from the official source on every run**, so you never screen against a stale copy.

- Screen one name or **100,000 customers or suppliers** in a single run, from a list, JSON objects or an Apify dataset.
- **Fuzzy matching** built for sanctions names: word order, accents, legal forms (LLC, GmbH, OOO…), transliterations (Mohammed / Muhammad) and every listed **alias** are handled.
- **Fewer false positives**: give a date of birth and a country, and matches born years apart are flagged instead of raised.
- **Evidence for every hit**: listed name, matched alias, list and programme (e.g. `RUSSIA-EO14024`), dates of birth, nationalities, addresses, ID documents, listing date, remarks and a link to the official entry.
- A clear **status and risk level** per name (`potential-match` / `clear`, high / medium / low), ready for a KYC workflow, Make, Zapier or your own API calls.

> Screening results are leads for a compliance review, not a legal determination. A potential match must be checked by a person against the official entry before any decision.

### What data can you get?

<table>
<tr><td>🧾 Status and risk level</td><td>🎯 Match score</td><td>👤 Listed name and alias</td></tr>
<tr><td>🌍 List and programme</td><td>🎂 Dates of birth</td><td>🏳️ Nationalities</td></tr>
<tr><td>📍 Addresses</td><td>🪪 ID documents</td><td>📅 Listing date</td></tr>
<tr><td>📝 Remarks</td><td>🔗 Official entry link</td><td>🗂️ List versions</td></tr>
</table>

### How to use it

1. Click **Try for free** and open the Actor.
2. Paste **names** or give objects with date of birth and country.
3. Choose the **lists** and the match threshold.
4. Click **Start** and review potential matches with their evidence.
5. Export, or schedule the task to rescreen your portfolio.

### Which lists are checked?

| List | Source | Typical size |
|---|---|---|
| US OFAC Specially Designated Nationals (SDN), with aliases and addresses | U.S. Treasury Sanctions List Service | ~19,500 entries |
| UN Security Council Consolidated List | United Nations | ~1,000 entries |
| EU Consolidated Financial Sanctions List | European Commission (FSF) | ~6,300 entries |
| UK Sanctions List | UK Foreign, Commonwealth & Development Office | ~6,400 entries |

Together that is about **33,000 listed people, companies, vessels and aircraft and 92,000 names and aliases**, indexed in a few seconds at the start of each run. If an official source can't be downloaded, the run stops **without charging** (you can opt in to screening with the lists that did load).

### Input examples

**Quick check of a few names**

```json
{
  "names": ["Vladimir Putin", "Rosneft", "Jane Doe"]
}
```

**KYC check with date of birth and country (fewer false positives)**

```json
{
  "entities": [
    { "name": "Viktor Bout", "dateOfBirth": "1967", "country": "Russia", "type": "person", "reference": "client-1042" },
    { "name": "Sberbank", "type": "organization", "reference": "supplier-77" }
  ],
  "threshold": 0.9
}
```

**Screen a whole customer list from another Actor's dataset, returning only hits**

```json
{
  "datasetId": "YOUR_DATASET_ID",
  "nameField": "companyName",
  "entityType": "organization",
  "lists": ["ofac", "eu", "uk"],
  "onlyMatches": true
}
```

Tip: save the input as a **task** and schedule it daily or weekly to re-screen your portfolio as the lists change.

### Output

One row per screened name. Real excerpt from a run in November 2026:

```json
{
  "query": "Vladimir Putin",
  "status": "potential-match",
  "riskLevel": "high",
  "topScore": 1,
  "topMatchName": "Vladimir Vladimirovich PUTIN",
  "topMatchList": "ofac",
  "topMatchPrograms": "RUSSIA-EO14024",
  "matchCount": 5,
  "listsHit": ["ofac", "uk", "eu"],
  "matches": [
    {
      "score": 1,
      "matchedName": "Vladimir PUTIN",
      "listedName": "Vladimir Vladimirovich PUTIN",
      "list": "ofac",
      "listEntryId": "35096",
      "entityType": "person",
      "programs": ["RUSSIA-EO14024"],
      "datesOfBirth": ["07 Oct 1952"],
      "nationalities": ["Russia"],
      "addresses": ["Kremlin, Moscow, Russia", "Novo-Ogaryevo, Moscow Region, Russia"],
      "sourceUrl": "https://sanctionssearch.ofac.treas.gov/Details.aspx?id=35096",
      "dobCheck": "not-checked",
      "countryCheck": "not-checked"
    }
  ],
  "listsChecked": ["ofac", "un", "eu", "uk"],
  "screenedAt": "2026-11-15T21:00:12.000Z"
}
```

| Field | Meaning |
|---|---|
| `status` | `potential-match`, `clear`, or `name-match-dob-differs` when the name matches but the listed person was born more than a year apart. |
| `riskLevel` | `high` (score ≥ 0.97), `medium` (≥ 0.92), `low`, or `clear`. |
| `topScore` / `score` | Name similarity from 0 to 1 (1 = same name, any word order), adjusted +0.03 for a matching birth year, −0.15 for a different one, +0.02 for a matching country. |
| `matchedName` / `listedName` | The alias that matched, and the entry's main name on the list. |
| `programs` | Sanctions programme or regime (e.g. `RUSSIA-EO14024`, `IRAN`, `DPRK`). |
| `dobCheck` / `countryCheck` | `match`, `mismatch` / `no-match`, or `not-checked` when you or the list gave no date or country. |
| `reference` | Your own ID, copied from the input so you can join results back. |

The key-value store record **SUMMARY** gives the counts and the version date of every list used, for your audit trail.

### How much does it cost?

**$5 per 1,000 names screened** ($0.005 per name), whether the name matches or not. Downloading and indexing the lists is included. A run that can't load an official list is not charged.

### More Actors from this developer

### FAQ

##### How accurate is the matching?

The score combines Jaro-Winkler similarity per word with a consonant "skeleton" that survives transliteration, compares every alias, and ignores word order and legal forms. On the default threshold (0.88), "Kim Jong Un", "Ramzan Kadyrov" or "Bank Melli Iran" match their entries, while ordinary names stay clear. Lower the threshold for more recall, raise it for exact checks.

##### How fresh are the lists?

They are downloaded from the official servers at the start of every run, and the SUMMARY record shows each list's publication date. Nothing is cached between runs.

##### Can I screen my whole customer database?

Yes. Put the names in a dataset (or the `entities` field) and run once; 10,000 names take about a minute. Use `reference` to map results back to your CRM.

##### Does this replace a compliance provider?

It covers the core government sanctions lists with transparent scoring and full evidence. It does not cover PEP lists, adverse media or other national lists, and it does not make legal decisions for you.

##### Can I use it through the API, Make, Zapier or Google Sheets?

Yes. Every run can be started and read through the [Apify API](https://docs.apify.com/api/v2) (JavaScript and Python clients, CLI, MCP), and Apify integrations connect it to Make, Zapier, n8n, Google Sheets, Slack, webhooks and more.

##### Is it legal to use this data?

The Actor only reads public or official open data and doesn't log in anywhere. Check the source's licence and your local rules (for example GDPR when data concerns people) for your use case; if in doubt, ask a lawyer.

##### Something isn't working, or you need another field?

Open an issue on the **Issues** tab: feedback is read and answered.

# Actor input Schema

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

People or companies, one per line. Word order, accents and legal forms (LLC, GmbH, SA…) don't matter.

## `entities` (type: `array`):

For fewer false positives, give objects with a date of birth (year is enough) and a country: <code>\[{"name": "Viktor Bout", "dateOfBirth": "1967", "country": "Russia", "type": "person", "reference": "client-42"}]</code>. <code>reference</code> is copied to the output so you can join results back to your records.

## `datasetId` (type: `string`):

ID of an Apify dataset with your customer or supplier list, for example the output of another Actor.

## `nameField` (type: `string`):

Field holding the name in each dataset item. Optional fields <code>dateOfBirth</code>, <code>country</code> and <code>reference</code> are used when present.

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

Which official lists to check. All four are downloaded fresh from the official sources on every run.

## `threshold` (type: `number`):

Minimum similarity (0.70–1.00) for a potential match. 0.88 suits most KYC checks; lower it to catch more spelling variants (more false positives), raise it for exact-name checks.

## `entityType` (type: `string`):

Compare only with listed people, or only with organisations (companies, vessels, aircraft). Per-name <code>type</code> in the details overrides it.

## `maxMatchesPerName` (type: `integer`):

Best matches returned for each name (all lists together).

## `onlyMatches` (type: `boolean`):

Skip the rows of clear names in the dataset. Every name is still screened and counted.

## `excludeDobMismatches` (type: `boolean`):

When you give a date of birth, matches born more than a year apart are shown with status <code>name-match-dob-differs</code>. Turn this on to drop them.

## `allowPartialLists` (type: `boolean`):

By default the run stops without charging if an official source can't be downloaded, so a screening is never silently incomplete. Turn on to screen with the lists that loaded.

## Actor input object example

```json
{
  "names": [
    "Vladimir Putin",
    "Rosneft",
    "Jane Doe"
  ],
  "nameField": "name",
  "lists": [
    "ofac",
    "un",
    "eu",
    "uk"
  ],
  "threshold": 0.88,
  "entityType": "any",
  "maxMatchesPerName": 5,
  "onlyMatches": false,
  "excludeDobMismatches": false,
  "allowPartialLists": false
}
```

# Actor output Schema

## `overview` (type: `string`):

Status, risk level and best match for every name.

## `matches` (type: `string`):

Every match with evidence.

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

Every field of every row.

## `summary` (type: `string`):

The SUMMARY record.

# 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 = {
    "names": [
        "Vladimir Putin",
        "Rosneft",
        "Jane Doe"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("yck69/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 = { "names": [
        "Vladimir Putin",
        "Rosneft",
        "Jane Doe",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("yck69/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 '{
  "names": [
    "Vladimir Putin",
    "Rosneft",
    "Jane Doe"
  ]
}' |
apify call yck69/sanctions-screening --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,yck69/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/6jgeXY6h6HF0Ewjaf/builds/3oKilPXkZwjfeHLVw/openapi.json
