# OFAC Sanctions Screener (SDN + Consolidated, Fuzzy Match) (`calculating_kitchen_h0b/ofac-sanctions-screener`) Actor

Bulk-screen people, companies and vessels against US Treasury OFAC SDN and Consolidated sanctions lists with fuzzy name and alias matching. Match score, programs, addresses, IDs. Also exports any sanctions program as a data feed. No API key.

- **URL**: https://apify.com/calculating_kitchen_h0b/ofac-sanctions-screener.md
- **Developed by:** [Andres Barcelo](https://apify.com/calculating_kitchen_h0b) (community)
- **Categories:** Business, Automation, Open source
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## OFAC Sanctions Screener (SDN + Consolidated List, Fuzzy Name Match)

Screen **people, companies, vessels and aircraft against the US Treasury OFAC sanctions lists** in bulk. Paste a list of names and get, for every name, a clear **match / no match** result, a **fuzzy match score (0-100)** and the top candidate sanctioned records with their **aliases, programs, addresses, countries, IDs and remarks**. Covers the **SDN list** (Specially Designated Nationals and Blocked Persons) and the **Consolidated (non-SDN) list** (SSI, NS-MBS, FSE, CAPTA, NS-CMIC, NS-PLC...). Data is downloaded fresh from OFAC's official Sanctions List Service on every run. No API key, no subscription, no setup.

A second **list mode** turns the Actor into a **sanctions data feed**: export every record for a program such as `RUSSIA-EO14024`, `SDGT`, `IRAN` or `DPRK3`, filtered by type and country.

### What it does

- Downloads the current OFAC SDN and Consolidated lists (names, aliases a.k.a./f.k.a./n.k.a., addresses, remarks) directly from `sanctionslistservice.ofac.treas.gov`
- **Normalizes names**: case, punctuation, diacritics (é -> e), token order ("PUTIN, Vladimir" = "Vladimir Putin") and company legal forms (LLC, Ltd, GmbH, OOO, PJSC, S.A....)
- **Fuzzy matches** each input name against every primary name and alias using RapidFuzz (token sort ratio by default; WRatio and token set optional), so spelling and transliteration variants are caught
- Returns **one dataset row per screened name**, ready for CSV/Excel/JSON export, API, webhooks, Zapier, Make or n8n
- Optional filters: **entity type** (individual, entity, vessel, aircraft), **country** (address, nationality, citizenship, vessel flag), **sanctions program**
- Merges records that appear on both lists and shows `onLists` so you know exactly where a hit comes from

### Use cases

- **KYC / AML onboarding**: screen new customers, beneficial owners and directors before account opening
- **Vendor and supplier onboarding**: third-party due diligence and procurement compliance
- **Payments, fintech and crypto**: batch-screen counterparties, merchants and payees
- **Export control and trade compliance**: check consignees, shipping companies and **vessels** (IMO numbers appear in remarks)
- **Periodic re-screening**: schedule a daily or weekly run over your customer base to catch new designations
- **Data feeds**: pull all `RUSSIA-EO14024` or `SDGT` designations into your own database, BI tool or AI agent (MCP)

### Input

| Field | Description |
|---|---|
| `mode` | `screen` (default) or `list` |
| `names` | Names to screen (people, companies, vessels, aircraft), any order or format |
| `minScore` | Match threshold 50-100, default **85** |
| `maxMatchesPerName` | Candidate records returned per name, default 5 |
| `matchAlgorithm` | `token_sort` (default), `wratio` or `token_set` |
| `includeAliases` | Match against aliases too (default true) |
| `lists` | `SDN`, `CONSOLIDATED` (default both) |
| `entityTypes` | Optional filter: `individual`, `entity`, `vessel`, `aircraft` |
| `countries` | Optional filter, e.g. `Russia`, `Iran`, `Venezuela` |
| `programs` | Optional filter in screen mode, main selector in list mode, e.g. `RUSSIA-EO14024` |
| `maxRecords` | List mode cap, default 1000 |

Screening example:

```json
{"names": ["Banco Nacional de Cuba", "Vladimir Putin", "Rosneft Trading", "Acme Widgets LLC"], "minScore": 85}
```

Data feed example (list mode):

```json
{"mode": "list", "programs": ["RUSSIA-EO14024"], "entityTypes": ["vessel"], "maxRecords": 500}
```

### Output

Screen mode, one row per input name:

```json
{
  "query": "Vladimir Putin",
  "matched": true,
  "bestScore": 100,
  "bestMatchName": "PUTIN, Vladimir Vladimirovich",
  "bestMatchPrograms": ["RUSSIA-EO14024"],
  "matchCount": 2,
  "topMatches": [{
    "score": 100, "name": "PUTIN, Vladimir Vladimirovich", "matchedName": "PUTIN, Vladimir Vladimirovich", "matchedOn": "primary",
    "type": "individual", "programs": ["RUSSIA-EO14024"], "list": "SDN", "onLists": ["SDN"], "uid": 35096,
    "countries": ["Russia"], "addresses": [{"address": "Kremlin", "cityStatePostal": "Moscow", "country": "Russia"}], "aliases": ["PUTIN, Vladimir"],
    "remarks": "DOB 07 Oct 1952; POB Leningrad, Russia; nationality Russia; Gender Male; ..."
  }],
  "threshold": 85, "listsChecked": ["SDN", "CONSOLIDATED"], "listFileDate": "2026-10-16", "screenedAt": "2026-10-20T15:18:30+00:00"
}
```

A clean name returns `"matched": false`, `"bestScore": 0` and an empty `topMatches` array, which is your documented evidence that the name was screened.

List mode returns full sanctions records: `uid`, `name`, `type`, `programs`, `onLists`, `aliases` (with type), `addresses`, `countries`, `remarks` (DOB, POB, passports, tax IDs, IMO numbers, linked entities), `title`, `callSign`, `vesselType`, `vesselFlag`, `vesselOwner`, `tonnage`.

### Pricing

Pay only for what you use (pay per event):

- **$3 per 1,000 names screened** ($0.003 per name), whether or not it matches
- **$1 per 1,000 sanctions records** returned in list mode ($0.001 per record)

No monthly fee. Screening 100 vendors costs $0.30.

### FAQ

**How fresh is the data?** Every run downloads the latest files OFAC publishes, and each row includes `listFileDate`, the publication date of the files used.

**What score threshold should I use?** 85 is a common starting point. Lower it to 80 for more transliteration variants (Arabic, Cyrillic and Korean names), raise it to 90+ to reduce false positives. Always review potential matches manually using DOB, nationality, addresses and IDs in `remarks`.

**Does it match aliases?** Yes. Every a.k.a., f.k.a. (formerly known as) and n.k.a. (now known as) alias is matched; `matchedName` and `matchedOn` show which one hit.

**Can I screen vessels?** Yes. Vessel names, call signs, flags, owners and IMO numbers (in remarks) are included; use `entityTypes: ["vessel"]`.

**Does it cover EU, UK or UN sanctions?** No, this Actor covers US OFAC lists (SDN and Consolidated non-SDN) only.

**Can I run it on a schedule or via API?** Yes, use Apify Schedules, the Apify API, webhooks or integrations (Zapier, Make, n8n, Google Sheets) to re-screen automatically.

### Disclaimer

This Actor is a **screening aid, not legal advice** and not a substitute for a compliance program. Fuzzy matching can produce false positives and false negatives; a match is a *potential* match that must be reviewed by a qualified person, and a non-match does not guarantee a party is not sanctioned (OFAC's 50% rule, ownership and control, and other lists are not covered). Always confirm results with the official OFAC Sanctions List Search (sanctionssearch.ofac.treas.gov). Data comes from the US Department of the Treasury, Office of Foreign Assets Control (public domain). Not affiliated with or endorsed by OFAC or the US Treasury.

# Actor input Schema

## `mode` (type: `string`):

<b>screen</b>: one output row per input name with match result and top matches. <b>list</b>: returns the sanctions records themselves (filtered by program, type and country).

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

People, companies, vessels or aircraft to check. Any order and format works (e.g. 'Vladimir Putin' or 'PUTIN, Vladimir'); case, punctuation, diacritics, token order and company legal forms (LLC, Ltd, OOO...) are normalized.

## `minScore` (type: `integer`):

Minimum fuzzy similarity score to count as a potential match. 85 is a common screening default; lower it (e.g. 80) to catch more transliteration variants, raise it (e.g. 92) to reduce false positives.

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

How many candidate sanctioned records to return for each screened name, best first.

## `matchAlgorithm` (type: `string`):

RapidFuzz scorer used to compare normalized names.

## `includeAliases` (type: `boolean`):

Also compare against every alias OFAC publishes for each record. Strongly recommended.

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

Which OFAC lists to load. Both by default.

## `entityTypes` (type: `array`):

Optional. Only match/return records of these types. Empty = all types.

## `countries` (type: `array`):

Optional. Only match/return records with an address, nationality, citizenship or vessel flag containing one of these (e.g. Russia, Iran, Venezuela).

## `programs` (type: `array`):

Optional in screen mode; main filter in list mode. OFAC program codes such as RUSSIA-EO14024, SDGT, IRAN, CUBA, DPRK, CYBER2, VENEZUELA-EO13850, GLOMAG, SDNTK.

## `maxRecords` (type: `integer`):

Cap on the number of sanctions records returned in list mode.

## Actor input object example

```json
{
  "mode": "screen",
  "names": [
    "Banco Nacional de Cuba",
    "Acme Widgets LLC"
  ],
  "minScore": 85,
  "maxMatchesPerName": 5,
  "matchAlgorithm": "token_sort",
  "includeAliases": true,
  "lists": [
    "SDN",
    "CONSOLIDATED"
  ],
  "programs": [
    "RUSSIA-EO14024"
  ],
  "maxRecords": 1000
}
```

# Actor output Schema

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

Screening results (one row per name) or sanctions records (list mode) in the default dataset (overview view).

# 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": [
        "Banco Nacional de Cuba",
        "Acme Widgets LLC"
    ],
    "programs": [
        "RUSSIA-EO14024"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("calculating_kitchen_h0b/ofac-sanctions-screener").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": [
        "Banco Nacional de Cuba",
        "Acme Widgets LLC",
    ],
    "programs": ["RUSSIA-EO14024"],
}

# Run the Actor and wait for it to finish
run = client.actor("calculating_kitchen_h0b/ofac-sanctions-screener").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": [
    "Banco Nacional de Cuba",
    "Acme Widgets LLC"
  ],
  "programs": [
    "RUSSIA-EO14024"
  ]
}' |
apify call calculating_kitchen_h0b/ofac-sanctions-screener --silent --output-dataset

```

## MCP server setup

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

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/sVb3kXAP2PMbaVEEp/builds/hp3Go7FhwS3B9G8lD/openapi.json