# OFAC Sanctions Screening API (SDN, UK OFSI, UN, EU Lists) (`lathewright/sanctions-screening`) Actor

Returns fuzzy-match screening results for names against the OFAC SDN and Consolidated, UK OFSI, UN Security Council and EU lists, downloaded fresh from the official files, with scores, aliases, programs and listing dates. For KYC/KYB, AP/AR checks and AI agents.

- **URL**: https://apify.com/lathewright/sanctions-screening.md
- **Developed by:** [lathewright LLC](https://apify.com/lathewright) (community)
- **Categories:** Business, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 33.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.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

## OFAC Sanctions Screening API (SDN, UK OFSI, UN, EU Lists)

Screen customers, suppliers and counterparties against the OFAC, UK OFSI, UN and EU sanctions lists with explainable fuzzy matching, for compliance teams, finance ops, KYC onboarding and AI agents. It costs $0.01 per name screened, however many lists you pick or hits come back, so 100 names cost $1. It is a screening aid, not legal advice.

Screen customers, suppliers, counterparties, vessels and beneficial owners against the official sanctions lists, downloaded fresh from the issuing authorities on every run: the US Treasury **OFAC SDN** list, the **OFAC Consolidated** (non-SDN) list, the **UK OFSI** consolidated list, the **UN Security Council** consolidated list and, optionally, the **EU** consolidated financial sanctions list. Matching is fuzzy and explainable: every hit carries a 0 to 100 score, the matched primary name or alias, entity type, programs or regime, countries, listing date and the authority's own remarks.

Built and maintained by **Lathewright**. Lathewright is operated by AI systems under human ownership. A person reviews and approves everything we publish, send and sell. **$0.01 per name screened**, regardless of how many lists you select or how many hits come back.

### Who uses it

- **KYC/KYB onboarding**: screen new customers and companies before activation; store the row as the audit record.
- **Accounts payable and procurement**: batch-screen vendor masters monthly.
- **Marketplaces and fintech agents**: an LLM agent calls this tool, reads `decision` and `topScore`, and escalates `potential-match` rows to a human.
- **Investigations**: see aliases and programs across all lists in one place.

### Example tasks

Paste any of these into the Input tab, or send the same JSON through the API. Prices are the per-result prices listed under Pricing.

#### 1. Screen three names against the default lists

```json
{
  "names": ["Rosneft", "Viktor Bout", "Acme Widgets LLC"]
}
```

What comes back: One row per name with `decision`, `topScore`, `matchCount`, `listsScreened` and a `matches` list with the matched name or alias, programs and listing date. $0.03.

#### 2. Stricter threshold, chosen lists

```json
{
  "names": ["Rosneft"],
  "lists": ["ofac-sdn", "eu"],
  "minScore": 90,
  "maxMatchesPerName": 3
}
```

What comes back: Only matches scoring 90 or higher on the OFAC SDN and EU lists, at most 3 per name.

#### 3. Limit matches to vessels and organizations

```json
{
  "names": ["Example Shipping Co"],
  "entityTypes": ["vessel", "entity"]
}
```

What comes back: Individuals and aircraft are ignored when matching.

### Input

```json
{
  "names": ["Rosneft", "Viktor Bout", "Acme Widgets LLC"],
  "lists": ["ofac-sdn", "ofac-consolidated", "uk-ofsi", "un"],
  "minScore": 85,
  "maxMatchesPerName": 5,
  "entityTypes": []
}
```

| Field | Type | Notes |
|---|---|---|
| `names` | array | People, companies, vessels (one per line) |
| `lists` | array | `ofac-sdn`, `ofac-consolidated`, `uk-ofsi`, `un`, `eu` (EU adds ~25 MB and ~20 s) |
| `minScore` | 50 to 100 | Similarity threshold; 85 default, 75 wide net, 95 near-exact |
| `maxMatchesPerName` | integer | Best hits to return per name |
| `entityTypes` | array | `individual`, `entity`, `vessel`, `aircraft` |

### Output (one row per screened name)

```json
{
  "name": "Viktor Bout",
  "decision": "potential-match",
  "topScore": 90,
  "matchCount": 1,
  "listsScreened": ["ofac-sdn", "ofac-consolidated", "uk-ofsi", "un"],
  "matches": [
    {
      "score": 90,
      "list": "ofac-sdn",
      "entityId": "9272",
      "matchedName": "BOUT, Viktor Anatolijevitch",
      "matchedNameType": "primary",
      "entityType": "individual",
      "programs": ["DRCONGO"],
      "countries": [],
      "listedOn": null,
      "details": "DOB 13 Jan 1967; alt. DOB 13 Jan 1970; POB Dushanbe, Tajikistan; ...",
      "sourceUrl": "https://ofac.treasury.gov/specially-designated-nationals-and-blocked-persons-list-sdn-human-readable-lists"
    }
  ],
  "minScore": 85,
  "listVersions": { "ofac-sdn": { "records": 39653, "ms": 3162 }, "uk-ofsi": { "records": 19761, "version": "03/06/2026" }, "un": { "records": 3776, "version": "2026-10-17T23:00:01.054Z" } },
  "screenedAt": "2026-10-19T05:12:40.000Z"
}
```

How scoring works: names are normalized (accents, punctuation, case, corporate suffixes), then compared on sorted tokens (Jaro-Winkler), token overlap and per-word alignment, so `Victor But` finds `BOUT, Viktor` and `Rosneft` finds all three `ROSNEFT` entries. Generic words (technologies, bank, international, trading…) are down-weighted so `Apify Technologies` does not match `Poly Technologies`. Aliases (a.k.a., f.k.a.) are searched as well as primary names.

### Pricing

| Event | Price |
|---|---|
| Name screened (`name-screened`) | $0.01 |

Plus Apify's start fee ($0.00005). 1,000 names = $10. The lists are cached for the day in a key-value store named `sanctions-lists-cache` in your account, so repeated runs on the same day skip the downloads.

### How to use it

- **Console**: paste names, Start, export the rows as your audit trail.
- **API**: `POST https://api.apify.com/v2/acts/lathewright~sanctions-screening/run-sync-get-dataset-items?token=<token>`
- **n8n / Make / Zapier**: Apify node → screen each new CRM contact or vendor → route `potential-match` to a review queue.

### Use from an AI agent (MCP)

Add this Actor as a tool in Claude, Cursor, VS Code or any MCP client with `https://mcp.apify.com/?tools=lathewright/sanctions-screening`. The Actor description is the tool description, and the input fields above are the tool parameters. Example prompts: "Screen these five vendors against OFAC and UK sanctions and tell me which need review", "Is Rosneft on any sanctions list and under which programs?".

### Data sources, fair use and limits

- OFAC SDN and Consolidated lists: Sanctions List Service CSV exports (public domain).
- UK OFSI consolidated list: HM Treasury CSV (Open Government Licence).
- UN Security Council consolidated list: official XML.
- EU consolidated list: European Commission CSV (reuse permitted).
- Screening a name is a suggestion, not a legal determination. Treat `potential-match` as "review by a person", confirm with identifiers (date of birth, registration numbers, addresses) and keep the row as evidence. PEP (politically exposed persons) and adverse media are not included.

### FAQ

**Why does a common name return several matches?** Fuzzy matching surfaces similar names on purpose. Raise `minScore`, restrict `entityTypes`, or compare the `details` field (dates of birth, places) with what you know.

**How fresh are the lists?** They are downloaded from the authorities at run time (cached for the current day). `listVersions` shows record counts and publication stamps where the source provides one.

# Actor input Schema

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

One name per line: individuals (`Viktor Bout`), companies (`Rosneft Oil Company`) or vessels.

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

Any of `ofac-sdn`, `ofac-consolidated` (non-SDN lists: SSI, FSE, CAPTA, NS-MBS…), `uk-ofsi`, `un`, `eu` (EU list is 25 MB and adds ~20 s). Default: OFAC SDN, OFAC consolidated, UK, UN.

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

0 to 100. Matches below this similarity are not reported. 85 catches spelling variants without drowning you in noise; use 75 for wide nets, 95 for near-exact.

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

Best matches to return for each screened name.

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

Limit matches to `individual`, `entity` (organizations), `vessel`, `aircraft`. Empty = all.

## `compactOutput` (type: `boolean`):

Return only the key fields (smaller, cheaper for AI agents to read).

## Actor input object example

```json
{
  "names": [
    "Rosneft",
    "Viktor Bout",
    "Acme Widgets LLC"
  ],
  "minScore": 85,
  "maxMatchesPerName": 5,
  "compactOutput": false
}
```

# Actor output Schema

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

One row per screened name with its matches.

# 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": [
        "Rosneft",
        "Viktor Bout",
        "Acme Widgets LLC"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lathewright/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": [
        "Rosneft",
        "Viktor Bout",
        "Acme Widgets LLC",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("lathewright/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": [
    "Rosneft",
    "Viktor Bout",
    "Acme Widgets LLC"
  ]
}' |
apify call lathewright/sanctions-screening --silent --output-dataset

```

## MCP server setup

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